feat(tornado): Support span streaming

sentry_sdk/consts.py

@@ -408,6 +408,12 @@ class SPANDATA:
  Example: template.cache.some_item.867da7e2af8e6b2f3aa7213a4080edb3
  """
 
+ CLIENT_ADDRESS = "client.address"
+ """
+ Client address of the network connection - IP address or Unix domain socket name.
+ Example: "10.1.2.80"
+ """
+
  CODE_FILEPATH = "code.filepath"
  """
  .. deprecated::
@@ -823,12 +829,25 @@ class SPANDATA:
  Example: GET
  """
 
+ HTTP_REQUEST_HEADER = "http.request.header"
+ """
+ Prefix for HTTP request header attributes. The header name (lowercased) is
+ appended to form the full attribute key.
+ Example: "http.request.header.content-type"
+ """
+
  HTTP_REQUEST_METHOD = "http.request.method"
  """
  The HTTP method used.
  Example: GET
  """
 
+ HTTP_REQUEST_BODY_DATA = "http.request.body.data"
+ """
+ The HTTP request body data as string.
+ Example: "[{\"role\": \"user\", \"message\": \"hello\"}]"
+ """
+
  HTTP_QUERY = "http.query"
  """
  The Query string present in the URL.
@@ -867,6 +886,12 @@ class SPANDATA:
  The messaging system's name, e.g. `kafka`, `aws_sqs`
  """
 
+ NETWORK_PROTOCOL_NAME = "network.protocol.name"
+ """
+ The application layer protocol name used for the network connection.
+ Example: "http", "https"
+ """
+
  NETWORK_PEER_ADDRESS = "network.peer.address"
  """
  Peer address of the network connection - IP address or Unix domain socket name.
@@ -946,6 +971,12 @@ class SPANDATA:
  Example: "MainThread"
  """
 
+ USER_IP_ADDRESS = "user.ip_address"
+ """
+ The IP address of the user that triggered the request.
+ Example: "10.1.2.80"
+ """
+
  URL_FULL = "url.full"
  """
  The URL of the resource that was fetched.

sentry_sdk/integrations/tornado.py

@@ -4,19 +4,23 @@
 
 import sentry_sdk
 from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration, _check_minimum_version
 from sentry_sdk.integrations._wsgi_common import (
  RequestExtractor,
  _filter_headers,
  _is_json_content_type,
+ request_body_within_bounds,
 )
 from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.traces import SegmentSource, StreamedSpan
 from sentry_sdk.tracing import TransactionSource
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
  CONTEXTVARS_ERROR_MESSAGE,
  HAS_REAL_CONTEXTVARS,
+ AnnotatedValue,
  capture_internal_exceptions,
  ensure_integration_enabled,
  event_from_exception,
@@ -33,9 +37,10 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
- from typing import Any, Callable, Dict, Generator, Optional
+ from typing import Any, Callable, ContextManager, Dict, Generator, Optional, Union
 
  from sentry_sdk._types import Event, EventProcessor
+ from sentry_sdk.tracing import Span
 
 
 class TornadoIntegration(Integration):
@@ -97,6 +102,9 @@ def sentry_log_exception(
  RequestHandler.log_exception = sentry_log_exception
 
 
+_DEFAULT_ROOT_SPAN_NAME = "generic Tornado request"
+
+
 @contextlib.contextmanager
 def _handle_request_impl(self: "RequestHandler") -> "Generator[None, None, None]":
  integration = sentry_sdk.get_client().get_integration(TornadoIntegration)
@@ -106,6 +114,8 @@ def _handle_request_impl(self: "RequestHandler") -> "Generator[None, None, None]
  return
 
  weak_handler = weakref.ref(self)
+ client = sentry_sdk.get_client()
+ is_span_streaming_enabled = has_span_streaming_enabled(client.options)
 
  with sentry_sdk.isolation_scope() as scope:
  headers = self.request.headers
@@ -114,22 +124,108 @@ def _handle_request_impl(self: "RequestHandler") -> "Generator[None, None, None]
  processor = _make_event_processor(weak_handler)
  scope.add_event_processor(processor)
 
- transaction = continue_trace(
- headers,
- op=OP.HTTP_SERVER,
- # Like with all other integrations, this is our
- # fallback transaction in case there is no route.
- # sentry_urldispatcher_resolve is responsible for
- # setting a transaction name later.
- name="generic Tornado request",
- source=TransactionSource.ROUTE,
- origin=TornadoIntegration.origin,
- )
-
- with sentry_sdk.start_transaction(
- transaction, custom_sampling_context={"tornado_request": self.request}
- ):
- yield
+ span_ctx: "ContextManager[Union[Span, StreamedSpan, None]]"
+
+ if is_span_streaming_enabled:
+ sentry_sdk.traces.continue_trace(dict(headers))
+ scope.set_custom_sampling_context({"tornado_request": self.request})
+
+ span_ctx = sentry_sdk.traces.start_span(
+ name=_DEFAULT_ROOT_SPAN_NAME,
+ attributes={
+ "sentry.op": OP.HTTP_SERVER,
+ "sentry.origin": TornadoIntegration.origin,
+ "sentry.span.source": SegmentSource.ROUTE,
+ },
+ parent_span=None,
+ )
+ else:
+ transaction = continue_trace(
+ headers,
+ op=OP.HTTP_SERVER,
+ # Like with all other integrations, this is our
+ # fallback transaction in case there is no route.
+ # sentry_urldispatcher_resolve is responsible for
+ # setting a transaction name later.
+ name=_DEFAULT_ROOT_SPAN_NAME,
+ source=TransactionSource.ROUTE,
+ origin=TornadoIntegration.origin,
+ )
+ span_ctx = sentry_sdk.start_transaction(
+ transaction,
+ custom_sampling_context={"tornado_request": self.request},
+ )
+
+ with span_ctx as span:
+ try:
+ yield
+ finally:
+ if type(span) is StreamedSpan:
+ with capture_internal_exceptions():
+ for attr, value in _get_request_attributes(
+ self.request
+ ).items():
+ span.set_attribute(attr, value)
+
+ with capture_internal_exceptions():
+ method = getattr(self, self.request.method.lower(), None)
+ if method is not None:
+ span_name = transaction_from_function(method)
+ if span_name:
+ span.name = span_name
+ span.set_attribute(
+ "sentry.span.source",
+ SegmentSource.COMPONENT,
+ )
+
+ with capture_internal_exceptions():
+ status_int = self.get_status()
+ span.set_attribute(SPANDATA.HTTP_STATUS_CODE, status_int)
+ span.status = "error" if status_int >= 400 else "ok"
+
+
+def _get_request_attributes(request: "Any") -> "Dict[str, Any]":
+ attributes = {} # type: Dict[str, Any]
+
+ if request.method:
+ attributes[SPANDATA.HTTP_REQUEST_METHOD] = request.method.upper()
+
+ headers = _filter_headers(dict(request.headers), use_annotated_value=False)
+ for header, value in headers.items():
+ attributes[f"{SPANDATA.HTTP_REQUEST_HEADER}.{header.lower()}"] = value
+
+ if request.query:
+ attributes[SPANDATA.URL_QUERY] = request.query
+
+ attributes[SPANDATA.URL_FULL] = request.full_url()
+
+ if request.protocol:
+ attributes[SPANDATA.NETWORK_PROTOCOL_NAME] = request.protocol
+
+ if should_send_default_pii() and request.remote_ip:
+ attributes[SPANDATA.CLIENT_ADDRESS] = request.remote_ip
+ attributes[SPANDATA.USER_IP_ADDRESS] = request.remote_ip
+
+ with capture_internal_exceptions():
+ raw_data = _get_tornado_request_data(request)
+ body_data = raw_data.value if isinstance(raw_data, AnnotatedValue) else raw_data
+ if body_data is not None:
+ attributes[SPANDATA.HTTP_REQUEST_BODY_DATA] = body_data
+
+ return attributes
+
+
+def _get_tornado_request_data(
+ request: "Any",
+) -> "Union[Optional[str], AnnotatedValue]":
+ body = request.body
+ if not body:
+ return None
+
+ if not request_body_within_bounds(sentry_sdk.get_client(), len(body)):
+ return AnnotatedValue.substituted_because_over_size_limit()
+
+ return body.decode("utf-8", "replace")
 
 
 @ensure_integration_enabled(TornadoIntegration)