sentry-sdk 2.46.0__tar.gz → 2.48.0__tar.gz

{sentry_sdk-2.46.0/sentry_sdk.egg-info → sentry_sdk-2.48.0}/PKG-INFO

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

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_compat.py

@@ -15,18 +15,15 @@ PY310 = sys.version_info[0] == 3 and sys.version_info[1] >= 10
 PY311 = sys.version_info[0] == 3 and sys.version_info[1] >= 11
 
 
-def with_metaclass(meta, *bases):
-    # type: (Any, *Any) -> Any
+def with_metaclass(meta: "Any", *bases: "Any") -> "Any":
     class MetaClass(type):
-        def __new__(metacls, name, this_bases, d):
-            # type: (Any, Any, Any, Any) -> Any
+        def __new__(metacls: "Any", name: "Any", this_bases: "Any", d: "Any") -> "Any":
             return meta(name, bases, d)
 
     return type.__new__(MetaClass, "temporary_class", (), {})
 
 
-def check_uwsgi_thread_support():
-    # type: () -> bool
+def check_uwsgi_thread_support() -> bool:
     # We check two things here:
     #
     # 1. uWSGI doesn't run in threaded mode by default -- issue a warning if
@@ -46,8 +43,7 @@ def check_uwsgi_thread_support():
 
     from sentry_sdk.consts import FALSE_VALUES
 
-    def enabled(option):
-        # type: (str) -> bool
+    def enabled(option: str) -> bool:
         value = opt.get(option, False)
         if isinstance(value, bool):
             return value

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_init_implementation.py

@@ -18,12 +18,10 @@ class _InitGuard:
         "functionality, and we will remove it in the next major release."
     )
 
-    def __init__(self, client):
-        # type: (sentry_sdk.Client) -> None
+    def __init__(self, client: "sentry_sdk.Client") -> None:
         self._client = client
 
-    def __enter__(self):
-        # type: () -> _InitGuard
+    def __enter__(self) -> "_InitGuard":
         warnings.warn(
             self._CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE,
             stacklevel=2,
@@ -32,8 +30,7 @@ class _InitGuard:
 
         return self
 
-    def __exit__(self, exc_type, exc_value, tb):
-        # type: (Any, Any, Any) -> None
+    def __exit__(self, exc_type: "Any", exc_value: "Any", tb: "Any") -> None:
         warnings.warn(
             self._CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE,
             stacklevel=2,
@@ -45,16 +42,14 @@ class _InitGuard:
             c.close()
 
 
-def _check_python_deprecations():
-    # type: () -> None
+def _check_python_deprecations() -> None:
     # Since we're likely to deprecate Python versions in the future, I'm keeping
     # this handy function around. Use this to detect the Python version used and
     # to output logger.warning()s if it's deprecated.
     pass
 
 
-def _init(*args, **kwargs):
-    # type: (*Optional[str], **Any) -> ContextManager[Any]
+def _init(*args: "Optional[str]", **kwargs: "Any") -> "ContextManager[Any]":
     """Initializes the SDK and optionally integrations.
 
     This takes the same arguments as the client constructor.

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_log_batcher.py

@@ -18,23 +18,21 @@ class LogBatcher:
 
     def __init__(
         self,
-        capture_func,  # type: Callable[[Envelope], None]
-        record_lost_func,  # type: Callable[..., None]
-    ):
-        # type: (...) -> None
-        self._log_buffer = []  # type: List[Log]
+        capture_func: "Callable[[Envelope], None]",
+        record_lost_func: "Callable[..., None]",
+    ) -> None:
+        self._log_buffer: "List[Log]" = []
         self._capture_func = capture_func
         self._record_lost_func = record_lost_func
         self._running = True
         self._lock = threading.Lock()
 
-        self._flush_event = threading.Event()  # type: threading.Event
+        self._flush_event: "threading.Event" = threading.Event()
 
-        self._flusher = None  # type: Optional[threading.Thread]
-        self._flusher_pid = None  # type: Optional[int]
+        self._flusher: "Optional[threading.Thread]" = None
+        self._flusher_pid: "Optional[int]" = None
 
-    def _ensure_thread(self):
-        # type: (...) -> bool
+    def _ensure_thread(self) -> bool:
         """For forking processes we might need to restart this thread.
         This ensures that our process actually has that thread running.
         """
@@ -66,8 +64,7 @@ class LogBatcher:
 
         return True
 
-    def _flush_loop(self):
-        # type: (...) -> None
+    def _flush_loop(self) -> None:
         while self._running:
             self._flush_event.wait(self.FLUSH_WAIT_TIME + random.random())
             self._flush_event.clear()
@@ -75,17 +72,28 @@ class LogBatcher:
 
     def add(
         self,
-        log,  # type: Log
-    ):
-        # type: (...) -> None
+        log: "Log",
+    ) -> None:
         if not self._ensure_thread() or self._flusher is None:
             return None
 
         with self._lock:
             if len(self._log_buffer) >= self.MAX_LOGS_BEFORE_DROP:
+                # Construct log envelope item without sending it to report lost bytes
+                log_item = Item(
+                    type="log",
+                    content_type="application/vnd.sentry.items.log+json",
+                    headers={
+                        "item_count": 1,
+                    },
+                    payload=PayloadRef(
+                        json={"items": [LogBatcher._log_to_transport_format(log)]}
+                    ),
+                )
                 self._record_lost_func(
                     reason="queue_overflow",
                     data_category="log_item",
+                    item=log_item,
                     quantity=1,
                 )
                 return None
@@ -94,8 +102,7 @@ class LogBatcher:
             if len(self._log_buffer) >= self.MAX_LOGS_BEFORE_FLUSH:
                 self._flush_event.set()
 
-    def kill(self):
-        # type: (...) -> None
+    def kill(self) -> None:
         if self._flusher is None:
             return
 
@@ -103,15 +110,12 @@ class LogBatcher:
         self._flush_event.set()
         self._flusher = None
 
-    def flush(self):
-        # type: (...) -> None
+    def flush(self) -> None:
         self._flush()
 
     @staticmethod
-    def _log_to_transport_format(log):
-        # type: (Log) -> Any
-        def format_attribute(val):
-            # type: (int | float | str | bool) -> Any
+    def _log_to_transport_format(log: "Log") -> "Any":
+        def format_attribute(val: "int | float | str | bool") -> "Any":
             if isinstance(val, bool):
                 return {"value": val, "type": "boolean"}
             if isinstance(val, int):
@@ -130,6 +134,7 @@ class LogBatcher:
         res = {
             "timestamp": int(log["time_unix_nano"]) / 1.0e9,
             "trace_id": log.get("trace_id", "00000000-0000-0000-0000-000000000000"),
+            "span_id": log.get("span_id"),
             "level": str(log["severity_text"]),
             "body": str(log["body"]),
             "attributes": {
@@ -139,9 +144,7 @@ class LogBatcher:
 
         return res
 
-    def _flush(self):
-        # type: (...) -> Optional[Envelope]
-
+    def _flush(self) -> "Optional[Envelope]":
         envelope = Envelope(
             headers={"sent_at": format_timestamp(datetime.now(timezone.utc))}
         )

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_lru_cache.py

@@ -8,17 +8,15 @@ _SENTINEL = object()
 
 
 class LRUCache:
-    def __init__(self, max_size):
-        # type: (int) -> None
+    def __init__(self, max_size: int) -> None:
         if max_size <= 0:
             raise AssertionError(f"invalid max_size: {max_size}")
         self.max_size = max_size
-        self._data = {}  # type: dict[Any, Any]
+        self._data: "dict[Any, Any]" = {}
         self.hits = self.misses = 0
         self.full = False
 
-    def set(self, key, value):
-        # type: (Any, Any) -> None
+    def set(self, key: "Any", value: "Any") -> None:
         current = self._data.pop(key, _SENTINEL)
         if current is not _SENTINEL:
             self._data[key] = value
@@ -29,8 +27,7 @@ class LRUCache:
             self._data[key] = value
         self.full = len(self._data) >= self.max_size
 
-    def get(self, key, default=None):
-        # type: (Any, Any) -> Any
+    def get(self, key: "Any", default: "Any" = None) -> "Any":
         try:
             ret = self._data.pop(key)
         except KeyError:
@@ -42,6 +39,5 @@ class LRUCache:
 
         return ret
 
-    def get_all(self):
-        # type: () -> list[tuple[Any, Any]]
+    def get_all(self) -> "list[tuple[Any, Any]]":
         return list(self._data.items())

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_metrics_batcher.py

@@ -18,23 +18,21 @@ class MetricsBatcher:
 
     def __init__(
         self,
-        capture_func,  # type: Callable[[Envelope], None]
-        record_lost_func,  # type: Callable[..., None]
-    ):
-        # type: (...) -> None
-        self._metric_buffer = []  # type: List[Metric]
+        capture_func: "Callable[[Envelope], None]",
+        record_lost_func: "Callable[..., None]",
+    ) -> None:
+        self._metric_buffer: "List[Metric]" = []
         self._capture_func = capture_func
         self._record_lost_func = record_lost_func
         self._running = True
         self._lock = threading.Lock()
 
-        self._flush_event = threading.Event()  # type: threading.Event
+        self._flush_event: "threading.Event" = threading.Event()
 
-        self._flusher = None  # type: Optional[threading.Thread]
-        self._flusher_pid = None  # type: Optional[int]
+        self._flusher: "Optional[threading.Thread]" = None
+        self._flusher_pid: "Optional[int]" = None
 
-    def _ensure_thread(self):
-        # type: (...) -> bool
+    def _ensure_thread(self) -> bool:
         if not self._running:
             return False
 
@@ -59,8 +57,7 @@ class MetricsBatcher:
 
         return True
 
-    def _flush_loop(self):
-        # type: (...) -> None
+    def _flush_loop(self) -> None:
         while self._running:
             self._flush_event.wait(self.FLUSH_WAIT_TIME + random.random())
             self._flush_event.clear()
@@ -68,9 +65,8 @@ class MetricsBatcher:
 
     def add(
         self,
-        metric,  # type: Metric
-    ):
-        # type: (...) -> None
+        metric: "Metric",
+    ) -> None:
         if not self._ensure_thread() or self._flusher is None:
             return None
 
@@ -87,8 +83,7 @@ class MetricsBatcher:
             if len(self._metric_buffer) >= self.MAX_METRICS_BEFORE_FLUSH:
                 self._flush_event.set()
 
-    def kill(self):
-        # type: (...) -> None
+    def kill(self) -> None:
         if self._flusher is None:
             return
 
@@ -96,15 +91,12 @@ class MetricsBatcher:
         self._flush_event.set()
         self._flusher = None
 
-    def flush(self):
-        # type: (...) -> None
+    def flush(self) -> None:
         self._flush()
 
     @staticmethod
-    def _metric_to_transport_format(metric):
-        # type: (Metric) -> Any
-        def format_attribute(val):
-            # type: (Union[int, float, str, bool]) -> Any
+    def _metric_to_transport_format(metric: "Metric") -> "Any":
+        def format_attribute(val: "Union[int, float, str, bool]") -> "Any":
             if isinstance(val, bool):
                 return {"value": val, "type": "boolean"}
             if isinstance(val, int):
@@ -134,9 +126,7 @@ class MetricsBatcher:
 
         return res
 
-    def _flush(self):
-        # type: (...) -> Optional[Envelope]
-
+    def _flush(self) -> "Optional[Envelope]":
         envelope = Envelope(
             headers={"sent_at": format_timestamp(datetime.now(timezone.utc))}
         )

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_queue.py

@@ -275,7 +275,7 @@ class Queue:
 
     # Initialize the queue representation
     def _init(self, maxsize):
-        self.queue = deque()  # type: Any
+        self.queue: "Any" = deque()
 
     def _qsize(self):
         return len(self.queue)

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_types.py

@@ -18,32 +18,27 @@ class AnnotatedValue:
 
     __slots__ = ("value", "metadata")
 
-    def __init__(self, value, metadata):
-        # type: (Optional[Any], Dict[str, Any]) -> None
+    def __init__(self, value: "Optional[Any]", metadata: "Dict[str, Any]") -> None:
         self.value = value
         self.metadata = metadata
 
-    def __eq__(self, other):
-        # type: (Any) -> bool
+    def __eq__(self, other: "Any") -> bool:
         if not isinstance(other, AnnotatedValue):
             return False
 
         return self.value == other.value and self.metadata == other.metadata
 
-    def __str__(self):
-        # type: (AnnotatedValue) -> str
+    def __str__(self: "AnnotatedValue") -> str:
         return str({"value": str(self.value), "metadata": str(self.metadata)})
 
-    def __len__(self):
-        # type: (AnnotatedValue) -> int
+    def __len__(self: "AnnotatedValue") -> int:
         if self.value is not None:
             return len(self.value)
         else:
             return 0
 
     @classmethod
-    def removed_because_raw_data(cls):
-        # type: () -> AnnotatedValue
+    def removed_because_raw_data(cls) -> "AnnotatedValue":
         """The value was removed because it could not be parsed. This is done for request body values that are not json nor a form."""
         return AnnotatedValue(
             value="",
@@ -58,8 +53,7 @@ class AnnotatedValue:
         )
 
     @classmethod
-    def removed_because_over_size_limit(cls, value=""):
-        # type: (Any) -> AnnotatedValue
+    def removed_because_over_size_limit(cls, value: "Any" = "") -> "AnnotatedValue":
         """
         The actual value was removed because the size of the field exceeded the configured maximum size,
         for example specified with the max_request_body_size sdk option.
@@ -77,8 +71,7 @@ class AnnotatedValue:
         )
 
     @classmethod
-    def substituted_because_contains_sensitive_data(cls):
-        # type: () -> AnnotatedValue
+    def substituted_because_contains_sensitive_data(cls) -> "AnnotatedValue":
         """The actual value was removed because it contained sensitive information."""
         return AnnotatedValue(
             value=SENSITIVE_DATA_SUBSTITUTE,
@@ -116,7 +109,7 @@ if TYPE_CHECKING:
     class SDKInfo(TypedDict):
         name: str
         version: str
-        packages: Sequence[Mapping[str, str]]
+        packages: "Sequence[Mapping[str, str]]"
 
     # "critical" is an alias of "fatal" recognized by Relay
     LogLevelStr = Literal["fatal", "critical", "error", "warning", "info", "debug"]
@@ -231,6 +224,7 @@ if TYPE_CHECKING:
             "attributes": dict[str, str | bool | float | int],
             "time_unix_nano": int,
             "trace_id": Optional[str],
+            "span_id": Optional[str],
         },
     )
 
@@ -294,6 +288,7 @@ if TYPE_CHECKING:
         "monitor",
         "span",
         "log_item",
+        "log_byte",
         "trace_metric",
     ]
     SessionStatus = Literal["ok", "exited", "crashed", "abnormal"]

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/_werkzeug.py

@@ -47,8 +47,7 @@ if TYPE_CHECKING:
 # We need this function because Django does not give us a "pure" http header
 # dict. So we might as well use it for all WSGI integrations.
 #
-def _get_headers(environ):
-    # type: (Dict[str, str]) -> Iterator[Tuple[str, str]]
+def _get_headers(environ: "Dict[str, str]") -> "Iterator[Tuple[str, str]]":
     """
     Returns only proper HTTP headers.
     """
@@ -67,8 +66,7 @@ def _get_headers(environ):
 # `get_host` comes from `werkzeug.wsgi.get_host`
 # https://github.com/pallets/werkzeug/blob/1.0.1/src/werkzeug/wsgi.py#L145
 #
-def get_host(environ, use_x_forwarded_for=False):
-    # type: (Dict[str, str], bool) -> str
+def get_host(environ: "Dict[str, str]", use_x_forwarded_for: bool = False) -> str:
     """
     Return the host for the given WSGI environment.
     """

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/ai/monitoring.py

@@ -17,22 +17,17 @@ if TYPE_CHECKING:
 _ai_pipeline_name = ContextVar("ai_pipeline_name", default=None)
 
 
-def set_ai_pipeline_name(name):
-    # type: (Optional[str]) -> None
+def set_ai_pipeline_name(name: "Optional[str]") -> None:
     _ai_pipeline_name.set(name)
 
 
-def get_ai_pipeline_name():
-    # type: () -> Optional[str]
+def get_ai_pipeline_name() -> "Optional[str]":
     return _ai_pipeline_name.get()
 
 
-def ai_track(description, **span_kwargs):
-    # type: (str, Any) -> Callable[[F], F]
-    def decorator(f):
-        # type: (F) -> F
-        def sync_wrapped(*args, **kwargs):
-            # type: (Any, Any) -> Any
+def ai_track(description: str, **span_kwargs: "Any") -> "Callable[[F], F]":
+    def decorator(f: "F") -> "F":
+        def sync_wrapped(*args: "Any", **kwargs: "Any") -> "Any":
             curr_pipeline = _ai_pipeline_name.get()
             op = span_kwargs.pop("op", "ai.run" if curr_pipeline else "ai.pipeline")
 
@@ -60,8 +55,7 @@ def ai_track(description, **span_kwargs):
                         _ai_pipeline_name.set(None)
                     return res
 
-        async def async_wrapped(*args, **kwargs):
-            # type: (Any, Any) -> Any
+        async def async_wrapped(*args: "Any", **kwargs: "Any") -> "Any":
             curr_pipeline = _ai_pipeline_name.get()
             op = span_kwargs.pop("op", "ai.run" if curr_pipeline else "ai.pipeline")
 
@@ -98,15 +92,13 @@ def ai_track(description, **span_kwargs):
 
 
 def record_token_usage(
-    span,
-    input_tokens=None,
-    input_tokens_cached=None,
-    output_tokens=None,
-    output_tokens_reasoning=None,
-    total_tokens=None,
-):
-    # type: (Span, Optional[int], Optional[int], Optional[int], Optional[int], Optional[int]) -> None
-
+    span: "Span",
+    input_tokens: "Optional[int]" = None,
+    input_tokens_cached: "Optional[int]" = None,
+    output_tokens: "Optional[int]" = None,
+    output_tokens_reasoning: "Optional[int]" = None,
+    total_tokens: "Optional[int]" = None,
+) -> None:
     # TODO: move pipeline name elsewhere
     ai_pipeline_name = get_ai_pipeline_name()
     if ai_pipeline_name:

{sentry_sdk-2.46.0 → sentry_sdk-2.48.0}/sentry_sdk/ai/utils.py

@@ -1,7 +1,9 @@
+import inspect
 import json
 from collections import deque
-from typing import TYPE_CHECKING
+from copy import deepcopy
 from sys import getsizeof
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Dict, List, Optional, Tuple
@@ -12,6 +14,8 @@ import sentry_sdk
 from sentry_sdk.utils import logger
 
 MAX_GEN_AI_MESSAGE_BYTES = 20_000  # 20KB
+# Maximum characters when only a single message is left after bytes truncation
+MAX_SINGLE_MESSAGE_CONTENT_CHARS = 10_000
 
 
 class GEN_AI_ALLOWED_MESSAGE_ROLES:
@@ -34,10 +38,14 @@ for target_role, source_roles in GEN_AI_MESSAGE_ROLE_REVERSE_MAPPING.items():
         GEN_AI_MESSAGE_ROLE_MAPPING[source_role] = target_role
 
 
-def _normalize_data(data, unpack=True):
-    # type: (Any, bool) -> Any
+def _normalize_data(data: "Any", unpack: bool = True) -> "Any":
     # convert pydantic data (e.g. OpenAI v1+) to json compatible format
     if hasattr(data, "model_dump"):
+        # Check if it's a class (type) rather than an instance
+        # Model classes can be passed as arguments (e.g., for schema definitions)
+        if inspect.isclass(data):
+            return f"<ClassType: {data.__name__}>"
+
         try:
             return _normalize_data(data.model_dump(), unpack=unpack)
         except Exception as e:
@@ -55,8 +63,9 @@ def _normalize_data(data, unpack=True):
     return data if isinstance(data, (int, float, bool, str)) else str(data)
 
 
-def set_data_normalized(span, key, value, unpack=True):
-    # type: (Span, str, Any, bool) -> None
+def set_data_normalized(
+    span: "Span", key: str, value: "Any", unpack: bool = True
+) -> None:
     normalized = _normalize_data(value, unpack=unpack)
     if isinstance(normalized, (int, float, bool, str)):
         span.set_data(key, normalized)
@@ -64,8 +73,7 @@ def set_data_normalized(span, key, value, unpack=True):
         span.set_data(key, json.dumps(normalized))
 
 
-def normalize_message_role(role):
-    # type: (str) -> str
+def normalize_message_role(role: str) -> str:
     """
     Normalize a message role to one of the 4 allowed gen_ai role values.
     Maps "ai" -> "assistant" and keeps other standard roles unchanged.
@@ -73,8 +81,7 @@ def normalize_message_role(role):
     return GEN_AI_MESSAGE_ROLE_MAPPING.get(role, role)
 
 
-def normalize_message_roles(messages):
-    # type: (list[dict[str, Any]]) -> list[dict[str, Any]]
+def normalize_message_roles(messages: "list[dict[str, Any]]") -> "list[dict[str, Any]]":
     """
     Normalize roles in a list of messages to use standard gen_ai role values.
     Creates a deep copy to avoid modifying the original messages.
@@ -92,8 +99,7 @@ def normalize_message_roles(messages):
     return normalized_messages
 
 
-def get_start_span_function():
-    # type: () -> Callable[..., Any]
+def get_start_span_function() -> "Callable[..., Any]":
     current_span = sentry_sdk.get_current_span()
     transaction_exists = (
         current_span is not None and current_span.containing_transaction is not None
@@ -101,8 +107,25 @@ def get_start_span_function():
     return sentry_sdk.start_span if transaction_exists else sentry_sdk.start_transaction
 
 
-def _find_truncation_index(messages, max_bytes):
-    # type: (List[Dict[str, Any]], int) -> int
+def _truncate_single_message_content_if_present(
+    message: "Dict[str, Any]", max_chars: int
+) -> "Dict[str, Any]":
+    """
+    Truncate a message's content to at most `max_chars` characters and append an
+    ellipsis if truncation occurs.
+    """
+    if not isinstance(message, dict) or "content" not in message:
+        return message
+    content = message["content"]
+
+    if not isinstance(content, str) or len(content) <= max_chars:
+        return message
+
+    message["content"] = content[:max_chars] + "..."
+    return message
+
+
+def _find_truncation_index(messages: "List[Dict[str, Any]]", max_bytes: int) -> int:
     """
     Find the index of the first message that would exceed the max bytes limit.
     Compute the individual message sizes, and return the index of the first message from the back
@@ -118,8 +141,21 @@ def _find_truncation_index(messages, max_bytes):
     return 0
 
 
-def truncate_messages_by_size(messages, max_bytes=MAX_GEN_AI_MESSAGE_BYTES):
-    # type: (List[Dict[str, Any]], int) -> Tuple[List[Dict[str, Any]], int]
+def truncate_messages_by_size(
+    messages: "List[Dict[str, Any]]",
+    max_bytes: int = MAX_GEN_AI_MESSAGE_BYTES,
+    max_single_message_chars: int = MAX_SINGLE_MESSAGE_CONTENT_CHARS,
+) -> "Tuple[List[Dict[str, Any]], int]":
+    """
+    Returns a truncated messages list, consisting of
+    - the last message, with its content truncated to `max_single_message_chars` characters,
+      if the last message's size exceeds `max_bytes` bytes; otherwise,
+    - the maximum number of messages, starting from the end of the `messages` list, whose total
+      serialized size does not exceed `max_bytes` bytes.
+
+    In the single message case, the serialized message size may exceed `max_bytes`, because
+    truncation is based only on character count in that case.
+    """
     serialized_json = json.dumps(messages, separators=(",", ":"))
     current_size = len(serialized_json.encode("utf-8"))
 
@@ -127,13 +163,26 @@ def truncate_messages_by_size(messages, max_bytes=MAX_GEN_AI_MESSAGE_BYTES):
         return messages, 0
 
     truncation_index = _find_truncation_index(messages, max_bytes)
-    return messages[truncation_index:], truncation_index
+    if truncation_index < len(messages):
+        truncated_messages = messages[truncation_index:]
+    else:
+        truncation_index = len(messages) - 1
+        truncated_messages = messages[-1:]
+
+    if len(truncated_messages) == 1:
+        truncated_messages[0] = _truncate_single_message_content_if_present(
+            deepcopy(truncated_messages[0]), max_chars=max_single_message_chars
+        )
+
+    return truncated_messages, truncation_index
 
 
 def truncate_and_annotate_messages(
-    messages, span, scope, max_bytes=MAX_GEN_AI_MESSAGE_BYTES
-):
-    # type: (Optional[List[Dict[str, Any]]], Any, Any, int) -> Optional[List[Dict[str, Any]]]
+    messages: "Optional[List[Dict[str, Any]]]",
+    span: "Any",
+    scope: "Any",
+    max_bytes: int = MAX_GEN_AI_MESSAGE_BYTES,
+) -> "Optional[List[Dict[str, Any]]]":
     if not messages:
         return None