add some attrs

Author: sentrivana

sentry_sdk/_span_batcher.py

@@ -10,7 +10,6 @@
 from typing import Optional, List, Callable, TYPE_CHECKING, Any
 
 from sentry_sdk.consts import SPANSTATUS
-from sentry_sdk.utils import format_attribute_value, format_timestamp, safe_repr
 from sentry_sdk.envelope import Envelope, Item, PayloadRef
 from sentry_sdk.tracing import Transaction
 
@@ -112,7 +111,6 @@ def add(self, span):
                 self.get_size() >= self.MAX_SPANS_BEFORE_FLUSH
             ):  # TODO[span-first] should this be per bucket?
                 self._flush_event.set()
-            print(self._span_buffer)
 
     def kill(self):
         # type: (...) -> None
@@ -130,6 +128,8 @@ def flush(self):
     @staticmethod
     def _span_to_transport_format(span):
         # type: (Span) -> SpanV2
+        from sentry_sdk.utils import attribute_value_to_transport_format, safe_repr
+
         res = {
             "trace_id": span.trace_id,
             "span_id": span.span_id,
@@ -145,15 +145,18 @@ def _span_to_transport_format(span):
         if span.parent_span_id:
             res["parent_span_id"] = span.parent_span_id
 
-        if span.attributes:
+        if span._attributes:
             res["attributes"] = {
-                k: format_attribute_value(v) for (k, v) in span["attributes"].items()
+                k: attribute_value_to_transport_format(v)
+                for (k, v) in span._attributes.items()
             }
 
         return res
 
     def _flush(self):
         # type: (...) -> Optional[Envelope]
+        from sentry_sdk.utils import format_timestamp
+
         with self._lock:
             if len(self._span_buffer) == 0:
                 return None

sentry_sdk/_types.py

@@ -223,14 +223,16 @@ class SDKInfo(TypedDict):
     # TODO: Make a proper type definition for this (PRs welcome!)
     Hint = Dict[str, Any]
 
-    # TODO: Consolidate attribute types. E.g. metrics use the same attr structure.
-    # I'm keeping span attrs separate for now so that the span first stuff is
-    # isolated until it's not experimental.
-    SpanAttributeValue = TypedDict(
-        "SpanAttributeValue",
+    AttributeValue = (
+        str | bool | float | int | list[str] | list[bool] | list[float] | list[int]
+    )
+    Attributes = dict[str, AttributeValue]
+
+    SerializedAttributeValue = TypedDict(
+        "SerializedAttributeValue",
         {
             "type": Literal["string", "boolean", "double", "integer"],
-            "value": str | bool | float | int,
+            "value": AttributeValue,
         },
     )
 
@@ -240,22 +242,14 @@ class SDKInfo(TypedDict):
             "severity_text": str,
             "severity_number": int,
             "body": str,
-            "attributes": dict[str, str | bool | float | int],
+            "attributes": Attributes,
             "time_unix_nano": int,
             "trace_id": Optional[str],
         },
     )
 
     MetricType = Literal["counter", "gauge", "distribution"]
 
-    MetricAttributeValue = TypedDict(
-        "MetricAttributeValue",
-        {
-            "value": Union[str, bool, float, int],
-            "type": Literal["string", "boolean", "double", "integer"],
-        },
-    )
-
     Metric = TypedDict(
         "Metric",
         {
@@ -266,7 +260,7 @@ class SDKInfo(TypedDict):
             "type": MetricType,
             "value": float,
             "unit": Optional[str],
-            "attributes": dict[str, str | bool | float | int],
+            "attributes": Attributes,
         },
     )
 
@@ -285,7 +279,7 @@ class SDKInfo(TypedDict):
             "is_segment": bool,
             "start_timestamp": float,
             "end_timestamp": float,
-            "attributes": Optional[dict[str, SpanAttributeValue]],
+            "attributes": Attributes,
         },
     )
 

sentry_sdk/client.py

@@ -12,6 +12,7 @@
 from sentry_sdk._compat import PY37, check_uwsgi_thread_support
 from sentry_sdk._metrics_batcher import MetricsBatcher
 from sentry_sdk._span_batcher import SpanBatcher
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     AnnotatedValue,
     ContextVar,
@@ -938,6 +939,7 @@ def capture_event(
 
     def _capture_log(self, log):
         # type: (Optional[Log]) -> None
+        # TODO[ivana]: Use get_default_attributes here
         if not has_logs_enabled(self.options) or log is None:
             return
 
@@ -1006,6 +1008,7 @@ def _capture_log(self, log):
 
     def _capture_metric(self, metric):
         # type: (Optional[Metric]) -> None
+        # TODO[ivana]: Use get_default_attributes here
         if not has_metrics_enabled(self.options) or metric is None:
             return
 

sentry_sdk/tracing.py

@@ -13,6 +13,8 @@
     logger,
     nanosecond_time,
     should_be_treated_as_error,
+    serialize_attribute,
+    get_default_attributes,
 )
 
 from typing import TYPE_CHECKING
@@ -44,6 +46,8 @@
         MeasurementUnit,
         SamplingContext,
         MeasurementValue,
+        Attributes,
+        AttributeValue,
     )
 
     class SpanKwargs(TypedDict, total=False):
@@ -282,7 +286,7 @@ class Span:
         "_flags",
         "_flags_capacity",
         "_mode",
-        "attributes",
+        "_attributes",
     )
 
     def __init__(
@@ -321,8 +325,7 @@ def __init__(
         self._containing_transaction = containing_transaction
         self._flags = {}  # type: Dict[str, bool]
         self._flags_capacity = 10
-        self.attributes = attributes or {}
-        # TODO[span-first]: fill attributes
+        self._attributes = attributes or {}  # type: Attributes
 
         if hub is not None:
             warnings.warn(
@@ -352,6 +355,16 @@ def __init__(
 
         self.update_active_thread()
         self.set_profiler_id(get_profiler_id())
+        self._set_initial_attributes()
+
+    def _set_initial_attributes(self):
+        attributes = get_default_attributes()
+        self._attributes = attributes | self._attributes
+
+        self._attributes["sentry.segment.id"] = self.containing_transaction.span_id
+        if hasattr(self.containing_transaction, "name"):
+            # TODO[span-first]: fix this properly
+            self._attributes["sentry.segment.name"] = self.containing_transaction.name
 
     # TODO this should really live on the Transaction class rather than the Span
     # class
@@ -631,6 +644,21 @@ def update_data(self, data):
         # type: (Dict[str, Any]) -> None
         self._data.update(data)
 
+    def get_attributes(self):
+        # type: () -> Attributes
+        return self._attributes
+
+    def set_attribute(self, attribute, value):
+        # type: (str, AttributeValue) -> None
+        self._attributes[attribute] = serialize_attribute(value)
+
+    def remove_attribute(self, attribute):
+        # type: (str) -> None
+        try:
+            del self._attributes[attribute]
+        except KeyError:
+            pass
+
     def set_flag(self, flag, result):
         # type: (str, bool) -> None
         if len(self._flags) < self._flags_capacity:

sentry_sdk/transport.py

@@ -475,7 +475,13 @@ def _send_envelope(self, envelope):
         print(envelope.headers)
         for i, item in enumerate(envelope.items):
             print("Item", i, item.type)
+            print("Headers")
             print(item.headers)
+            print("Attributes")
+            for i in item.payload.json["items"]:
+                for attribute, value in i["attributes"].items():
+                    print(attribute, value)
+            print("Payload")
             print(item.payload.json)
             print()
 

sentry_sdk/utils.py

@@ -30,6 +30,7 @@
     DEFAULT_ADD_FULL_STACK,
     DEFAULT_MAX_STACK_FRAMES,
     DEFAULT_MAX_VALUE_LENGTH,
+    SPANDATA,
     EndpointType,
 )
 from sentry_sdk._types import Annotated, AnnotatedValue, SENSITIVE_DATA_SUBSTITUTE
@@ -1726,6 +1727,85 @@ def is_sentry_url(client, url):
     )
 
 
+def serialize_attribute(value):
+    # type: (Any) -> AttributeValue
+    # check for allowed primitives
+    if isinstance(value, (int, str, float, bool)):
+        return value
+
+    # lists are allowed too, as long as they don't mix types
+    if isinstance(value, (list, tuple)):
+        for type_ in (int, str, float, bool):
+            if all(isinstance(item, type_) for item in value):
+                return list(value)
+
+    return safe_repr(value)
+
+
+def attribute_value_to_transport_format(value):
+    # type: (Any) -> dict[str, bool | str | int | float]
+    if isinstance(value, bool):
+        return {"value": value, "type": "boolean"}
+
+    if isinstance(value, int):
+        return {"value": value, "type": "integer"}
+
+    if isinstance(value, float):
+        return {"value": value, "type": "double"}
+
+    if isinstance(value, str):
+        return {"value": value, "type": "string"}
+
+    return {"value": safe_repr(value), "type": "string"}
+
+
+def get_default_attributes():
+    # type: () -> Attributes
+    # TODO[ivana]: standardize attr names into an enum/take from sentry convs
+    from sentry_sdk.client import SDK_INFO
+    from sentry_sdk.scope import should_send_default_pii
+
+    attributes = {}
+
+    attributes["sentry.sdk.name"] = SDK_INFO["name"]
+    attributes["sentry.sdk.version"] = SDK_INFO["version"]
+
+    options = sentry_sdk.get_client().options
+
+    server_name = options.get("server_name")
+    if server_name is not None:
+        attributes[SPANDATA.SERVER_ADDRESS] = server_name
+
+    environment = options.get("environment")
+    if environment is not None:
+        attributes["sentry.environment"] = environment
+
+    release = options.get("release")
+    if release is not None:
+        attributes["sentry.release"] = release
+
+    thread_id, thread_name = get_current_thread_meta()
+    if thread_id is not None:
+        attributes["thread.id"] = thread_id
+    if thread_name is not None:
+        attributes["thread.name"] = thread_name
+
+    # The user, if present, is always set on the isolation scope.
+    # TODO[ivana]: gate behing PII?
+    if should_send_default_pii():
+        isolation_scope = sentry_sdk.get_isolation_scope()
+        if isolation_scope._user is not None:
+            for attribute, user_attribute in (
+                ("user.id", "id"),
+                ("user.name", "username"),
+                ("user.email", "email"),
+            ):
+                if attribute in isolation_scope._user:
+                    attributes[attribute] = isolation_scope._user[user_attribute]
+
+    return attributes
+
+
 def _generate_installed_modules():
     # type: () -> Iterator[Tuple[str, str]]
     try:
@@ -2076,20 +2156,3 @@ def get_before_send_metric(options):
     return options.get("before_send_metric") or options["_experiments"].get(
         "before_send_metric"
     )
-
-
-def format_attribute_value(value):
-    # type: (Any) -> dict[str, bool | str | int | float]
-    if isinstance(value, bool):
-        return {"value": value, "type": "boolean"}
-
-    if isinstance(value, int):
-        return {"value": value, "type": "integer"}
-
-    if isinstance(value, float):
-        return {"value": value, "type": "double"}
-
-    if isinstance(value, str):
-        return {"value": value, "type": "string"}
-
-    return {"value": safe_repr(value), "type": "string"}