Addressing comments

Author: AlexLu2016

libraries/microsoft-agents-a365-observability-core/microsoft_agents_a365/observability/core/config.py

@@ -180,6 +180,7 @@ def _configure_internal(
                 token_resolver=exporter_options.token_resolver,
                 cluster_category=exporter_options.cluster_category,
                 use_s2s_endpoint=exporter_options.use_s2s_endpoint,
+                max_payload_bytes=exporter_options.max_payload_bytes,
             )
 
         else:

libraries/microsoft-agents-a365-observability-core/microsoft_agents_a365/observability/core/exporters/agent365_exporter.py

@@ -104,7 +104,8 @@ def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
                 )
 
                 if len(chunks) > 1:
-                    logger.info(
+                    # Logged at DEBUG to avoid leaking tenant/agent IDs in production logs.
+                    logger.debug(
                         f"Split {len(activities)} spans into {len(chunks)} chunks "
                         f"for tenantId: {tenant_id}, agentId: {agent_id}"
                     )
@@ -151,10 +152,21 @@ def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
                     payload = self._build_envelope(chunk, resource_attrs)
                     body = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
                     body_bytes = len(body.encode("utf-8"))
-                    logger.info(
+                    logger.debug(
                         f"Sending chunk {i + 1} of {len(chunks)} "
                         f"({len(chunk)} spans, {body_bytes} bytes)"
                     )
+                    # Defensive check: the estimator covers per-span content but not
+                    # envelope overhead (resource attributes, scope wrappers). Warn if
+                    # the assembled body exceeds the configured limit so operators can
+                    # observe estimator drift before the server starts rejecting requests.
+                    if body_bytes > self._max_payload_bytes:
+                        logger.warning(
+                            f"Chunk {i + 1} of {len(chunks)} body size ({body_bytes} bytes) "
+                            f"exceeds max_payload_bytes ({self._max_payload_bytes}); "
+                            "estimator may be under-counting envelope overhead. "
+                            f"Tenant: {tenant_id}, agent: {agent_id}, spans: {len(chunk)}."
+                        )
 
                     ok = self._post_with_retries(url, body, headers)
                     if not ok:

libraries/microsoft-agents-a365-observability-core/microsoft_agents_a365/observability/core/exporters/agent365_exporter_options.py

@@ -3,6 +3,8 @@
 
 from typing import Awaitable, Callable, Optional
 
+from .utils import DEFAULT_MAX_PAYLOAD_BYTES
+
 
 class Agent365ExporterOptions:
     """
@@ -19,6 +21,7 @@ def __init__(
         scheduled_delay_ms: int = 5000,
         exporter_timeout_ms: int = 30000,
         max_export_batch_size: int = 512,
+        max_payload_bytes: int = DEFAULT_MAX_PAYLOAD_BYTES,
     ):
         """
         Args:
@@ -29,6 +32,10 @@ def __init__(
             scheduled_delay_ms: Delay between export batches (ms). Default is 5000.
             exporter_timeout_ms: Timeout for the export operation (ms). Default is 30000.
             max_export_batch_size: Maximum batch size for export operations. Default is 512.
+            max_payload_bytes: Upper bound on HTTP request body size in bytes. The exporter
+                splits per-identity batches into sub-batches whose estimated size stays under
+                this limit, providing headroom under the A365 1 MB server limit. Default is
+                900_000 (~100 KB headroom for estimator error and JSON envelope overhead).
         """
         self.cluster_category = cluster_category
         self.token_resolver = token_resolver
@@ -37,3 +44,4 @@ def __init__(
         self.scheduled_delay_ms = scheduled_delay_ms
         self.exporter_timeout_ms = exporter_timeout_ms
         self.max_export_batch_size = max_export_batch_size
+        self.max_payload_bytes = max_payload_bytes

libraries/microsoft-agents-a365-observability-core/microsoft_agents_a365/observability/core/exporters/utils.py

@@ -354,19 +354,33 @@ def chunk_by_size(
 ) -> list[list[T]]:
     """Split items into sub-batches whose cumulative estimated size stays under ``max_chunk_bytes``.
 
+    Multi-item chunks are guaranteed to stay within the limit. A single item
+    whose estimated size exceeds ``max_chunk_bytes`` forms its own one-item
+    chunk (never silently dropped) even though that chunk exceeds the limit.
+
     Invariants:
     - Input order is preserved across chunks.
     - Empty input produces empty output.
-    - A single item whose size exceeds ``max_chunk_bytes`` forms its own
-      single-item chunk (never silently dropped).
+    - No item is ever dropped.
     - No chunk is ever empty.
+
+    Raises:
+        ValueError: If ``max_chunk_bytes`` is not positive, or if ``get_size``
+            returns a negative value for any item.
     """
+    if max_chunk_bytes <= 0:
+        raise ValueError(f"max_chunk_bytes must be positive, got {max_chunk_bytes}")
+
     chunks: list[list[T]] = []
     current: list[T] = []
     current_bytes = 0
 
     for item in items:
         item_bytes = get_size(item)
+        if item_bytes < 0:
+            raise ValueError(
+                f"get_size returned a negative value ({item_bytes}); sizes must be non-negative"
+            )
         if current and current_bytes + item_bytes > max_chunk_bytes:
             chunks.append(current)
             current = []

tests/observability/core/exporters/test_payload_chunking.py

@@ -107,6 +107,18 @@ def test_multi_item_chunks_respect_limit_no_chunk_is_empty(self) -> None:
             if len(chunk) > 1:
                 self.assertLessEqual(sum(item["size"] for item in chunk), 500_000)
 
+    def test_rejects_zero_max_chunk_bytes(self) -> None:
+        with self.assertRaises(ValueError):
+            chunk_by_size([{"id": "s", "size": 1}], self._get_size, 0)
+
+    def test_rejects_negative_max_chunk_bytes(self) -> None:
+        with self.assertRaises(ValueError):
+            chunk_by_size([{"id": "s", "size": 1}], self._get_size, -1)
+
+    def test_rejects_negative_item_size(self) -> None:
+        with self.assertRaises(ValueError):
+            chunk_by_size([{"id": "s", "size": -1}], self._get_size, 100)
+
 
 class TestTruncateSpanVerification(unittest.TestCase):
     MAX = 250 * 1024

tests/observability/core/test_agent365.py

@@ -120,6 +120,7 @@ def test_batch_span_processor_and_exporter_called_with_correct_values(
             token_resolver=self.mock_token_resolver,
             cluster_category="staging",
             use_s2s_endpoint=True,
+            max_payload_bytes=900_000,
         )
 
         # Verify BatchSpanProcessor was called with correct parameters from exporter_options

tests/observability/core/test_spectra_exporter.py

@@ -188,6 +188,7 @@ def test_configure_with_agent365_options_unchanged(self, mock_is_enabled, mock_e
             token_resolver=mock_token_resolver,
             cluster_category="staging",
             use_s2s_endpoint=True,
+            max_payload_bytes=900_000,
         )
 
     @patch("microsoft_agents_a365.observability.core.config.OTLPSpanExporter")