aiqa-client 0.3.1__tar.gz → 0.3.4__tar.gz

{aiqa_client-0.3.1/aiqa_client.egg-info → aiqa_client-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.3.1
+Version: 0.3.4
 Summary: OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server
 Author-email: AIQA <info@aiqa.dev>
 License: MIT

{aiqa_client-0.3.1 → aiqa_client-0.3.4}/aiqa/__init__.py

@@ -40,7 +40,7 @@ from .tracing import (
 from .client import get_aiqa_client
 from .experiment_runner import ExperimentRunner
 
-__version__ = "0.3.1"
+__version__ = "0.3.4"
 
 __all__ = [
     "WithTracing",

{aiqa_client-0.3.1 → aiqa_client-0.3.4}/aiqa/aiqa_exporter.py

@@ -27,6 +27,7 @@ class AIQASpanExporter(SpanExporter):
         server_url: Optional[str] = None,
         api_key: Optional[str] = None,
         flush_interval_seconds: float = 5.0,
+        max_batch_size_bytes: int = 5 * 1024 * 1024,  # 5MB default
     ):
         """
         Initialize the AIQA span exporter.
@@ -35,10 +36,12 @@ class AIQASpanExporter(SpanExporter):
             server_url: URL of the AIQA server (defaults to AIQA_SERVER_URL env var)
             api_key: API key for authentication (defaults to AIQA_API_KEY env var)
             flush_interval_seconds: How often to flush spans to the server
+            max_batch_size_bytes: Maximum size of a single batch in bytes (default: 5mb)
         """
         self._server_url = server_url
         self._api_key = api_key
         self.flush_interval_ms = flush_interval_seconds * 1000
+        self.max_batch_size_bytes = max_batch_size_bytes
         self.buffer: List[Dict[str, Any]] = []
         self.buffer_span_keys: set = set()  # Track (traceId, spanId) tuples to prevent duplicates (Python 3.8 compatible)
         self.buffer_lock = threading.Lock()
@@ -243,6 +246,59 @@ class AIQASpanExporter(SpanExporter):
             self.buffer.clear()
             self.buffer_span_keys.clear()
 
+    def _split_into_batches(self, spans: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+        """
+        Split spans into batches based on max_batch_size_bytes.
+        Each batch will be as large as possible without exceeding the limit.
+        If a single span exceeds the limit, it will be sent in its own batch with a warning.
+        """
+        if not spans:
+            return []
+        
+        batches = []
+        current_batch = []
+        current_batch_size = 0
+        
+        for span in spans:
+            # Estimate size of this span when serialized
+            span_json = json.dumps(span)
+            span_size = len(span_json.encode('utf-8'))
+            
+            # Check if this single span exceeds the limit
+            if span_size > self.max_batch_size_bytes:
+                # If we have a current batch, save it first
+                if current_batch:
+                    batches.append(current_batch)
+                    current_batch = []
+                    current_batch_size = 0
+                
+                # Log warning about oversized span
+                span_name = span.get('name', 'unknown')
+                span_trace_id = span.get('traceId', 'unknown')
+                logger.warning(
+                    f"Span '{span_name}' (traceId={span_trace_id}) exceeds max_batch_size_bytes "
+                    f"({span_size} bytes > {self.max_batch_size_bytes} bytes). "
+                    f"Will attempt to send it anyway - may fail if server/nginx limit is exceeded."
+                )
+                # Still create a batch with just this span - we'll try to send it
+                batches.append([span])
+                continue
+            
+            # If adding this span would exceed the limit, start a new batch
+            if current_batch and current_batch_size + span_size > self.max_batch_size_bytes:
+                batches.append(current_batch)
+                current_batch = []
+                current_batch_size = 0
+            
+            current_batch.append(span)
+            current_batch_size += span_size
+        
+        # Add the last batch if it has any spans
+        if current_batch:
+            batches.append(current_batch)
+        
+        return batches
+
     async def flush(self) -> None:
         """
         Flush buffered spans to the server. Thread-safe: ensures only one flush operation runs at a time.
@@ -345,77 +401,108 @@ class AIQASpanExporter(SpanExporter):
         logger.info(f"Auto-flush thread started: {flush_thread.name} (daemon={flush_thread.daemon})")
 
     async def _send_spans(self, spans: List[Dict[str, Any]]) -> None:
-        """Send spans to the server API (async)."""
+        """Send spans to the server API (async). Batches large payloads automatically."""
         import aiohttp
 
+        # Split into batches if needed
+        batches = self._split_into_batches(spans)
+        if len(batches) > 1:
+            logger.info(f"_send_spans() splitting {len(spans)} spans into {len(batches)} batches")
+        
         url = self._get_span_url()
         headers = self._build_request_headers()
-        logger.debug(f"_send_spans() sending {len(spans)} spans to {url}")
+        
         if self.api_key:
             logger.debug("_send_spans() using API key authentication")
         else:
             logger.debug("_send_spans() no API key provided")
 
-        try:
-            # Pre-serialize JSON to bytes and wrap in BytesIO to avoid blocking event loop
-            json_bytes = json.dumps(spans).encode('utf-8')
-            data = io.BytesIO(json_bytes)
-            
-            async with aiohttp.ClientSession() as session:
-                logger.debug(f"_send_spans() POST request starting to {url}")
-                async with session.post(url, data=data, headers=headers) as response:
-                    logger.debug(f"_send_spans() received response: status={response.status}")
-                    if not response.ok:
-                        error_text = await response.text()
-                        logger.error(
-                            f"_send_spans() failed: status={response.status}, "
-                            f"reason={response.reason}, error={error_text[:200]}"
-                        )
-                        raise Exception(
-                            f"Failed to send spans: {response.status} {response.reason} - {error_text}"
-                        )
-                    logger.debug(f"_send_spans() successfully sent {len(spans)} spans")
-        except RuntimeError as e:
-            if self._is_interpreter_shutdown_error(e):
-                if self.shutdown_requested:
-                    logger.debug(f"_send_spans() skipped due to interpreter shutdown: {e}")
-                else:
-                    logger.warning(f"_send_spans() interrupted by interpreter shutdown: {e}")
-                raise
-            logger.error(f"_send_spans() RuntimeError: {type(e).__name__}: {e}")
-            raise
-        except Exception as e:
-            logger.error(f"_send_spans() exception: {type(e).__name__}: {e}")
-            raise
+        errors = []
+        async with aiohttp.ClientSession() as session:
+            for batch_idx, batch in enumerate(batches):
+                try:
+                    logger.debug(f"_send_spans() sending batch {batch_idx + 1}/{len(batches)} with {len(batch)} spans to {url}")
+                    # Pre-serialize JSON to bytes and wrap in BytesIO to avoid blocking event loop
+                    json_bytes = json.dumps(batch).encode('utf-8')
+                    data = io.BytesIO(json_bytes)
+                    
+                    async with session.post(url, data=data, headers=headers) as response:
+                        logger.debug(f"_send_spans() batch {batch_idx + 1} received response: status={response.status}")
+                        if not response.ok:
+                            error_text = await response.text()
+                            error_msg = f"Failed to send batch {batch_idx + 1}/{len(batches)}: {response.status} {response.reason} - {error_text[:200]}"
+                            logger.error(f"_send_spans() {error_msg}")
+                            errors.append((batch_idx + 1, error_msg))
+                            # Continue with other batches even if one fails
+                            continue
+                        logger.debug(f"_send_spans() batch {batch_idx + 1} successfully sent {len(batch)} spans")
+                except RuntimeError as e:
+                    if self._is_interpreter_shutdown_error(e):
+                        if self.shutdown_requested:
+                            logger.debug(f"_send_spans() skipped due to interpreter shutdown: {e}")
+                        else:
+                            logger.warning(f"_send_spans() interrupted by interpreter shutdown: {e}")
+                        raise
+                    error_msg = f"RuntimeError in batch {batch_idx + 1}: {type(e).__name__}: {e}"
+                    logger.error(f"_send_spans() {error_msg}")
+                    errors.append((batch_idx + 1, error_msg))
+                    # Continue with other batches
+                except Exception as e:
+                    error_msg = f"Exception in batch {batch_idx + 1}: {type(e).__name__}: {e}"
+                    logger.error(f"_send_spans() {error_msg}")
+                    errors.append((batch_idx + 1, error_msg))
+                    # Continue with other batches
+        
+        # If any batches failed, raise an exception with details
+        if errors:
+            error_summary = "; ".join([f"batch {idx}: {msg}" for idx, msg in errors])
+            raise Exception(f"Failed to send some spans: {error_summary}")
+        
+        logger.debug(f"_send_spans() successfully sent all {len(spans)} spans in {len(batches)} batch(es)")
 
     def _send_spans_sync(self, spans: List[Dict[str, Any]]) -> None:
-        """Send spans to the server API (synchronous, for shutdown scenarios)."""
+        """Send spans to the server API (synchronous, for shutdown scenarios). Batches large payloads automatically."""
         import requests
 
+        # Split into batches if needed
+        batches = self._split_into_batches(spans)
+        if len(batches) > 1:
+            logger.info(f"_send_spans_sync() splitting {len(spans)} spans into {len(batches)} batches")
+        
         url = self._get_span_url()
         headers = self._build_request_headers()
-        logger.debug(f"_send_spans_sync() sending {len(spans)} spans to {url}")
+        
         if self.api_key:
             logger.debug("_send_spans_sync() using API key authentication")
         else:
             logger.debug("_send_spans_sync() no API key provided")
 
-        try:
-            response = requests.post(url, json=spans, headers=headers, timeout=10.0)
-            logger.debug(f"_send_spans_sync() received response: status={response.status_code}")
-            if not response.ok:
-                error_text = response.text[:200] if response.text else ""
-                logger.error(
-                    f"_send_spans_sync() failed: status={response.status_code}, "
-                    f"reason={response.reason}, error={error_text}"
-                )
-                raise Exception(
-                    f"Failed to send spans: {response.status_code} {response.reason} - {error_text}"
-                )
-            logger.debug(f"_send_spans_sync() successfully sent {len(spans)} spans")
-        except Exception as e:
-            logger.error(f"_send_spans_sync() exception: {type(e).__name__}: {e}")
-            raise
+        errors = []
+        for batch_idx, batch in enumerate(batches):
+            try:
+                logger.debug(f"_send_spans_sync() sending batch {batch_idx + 1}/{len(batches)} with {len(batch)} spans to {url}")
+                response = requests.post(url, json=batch, headers=headers, timeout=10.0)
+                logger.debug(f"_send_spans_sync() batch {batch_idx + 1} received response: status={response.status_code}")
+                if not response.ok:
+                    error_text = response.text[:200] if response.text else ""
+                    error_msg = f"Failed to send batch {batch_idx + 1}/{len(batches)}: {response.status_code} {response.reason} - {error_text}"
+                    logger.error(f"_send_spans_sync() {error_msg}")
+                    errors.append((batch_idx + 1, error_msg))
+                    # Continue with other batches even if one fails
+                    continue
+                logger.debug(f"_send_spans_sync() batch {batch_idx + 1} successfully sent {len(batch)} spans")
+            except Exception as e:
+                error_msg = f"Exception in batch {batch_idx + 1}: {type(e).__name__}: {e}"
+                logger.error(f"_send_spans_sync() {error_msg}")
+                errors.append((batch_idx + 1, error_msg))
+                # Continue with other batches
+        
+        # If any batches failed, raise an exception with details
+        if errors:
+            error_summary = "; ".join([f"batch {idx}: {msg}" for idx, msg in errors])
+            raise Exception(f"Failed to send some spans: {error_summary}")
+        
+        logger.debug(f"_send_spans_sync() successfully sent all {len(spans)} spans in {len(batches)} batch(es)")
 
     def shutdown(self) -> None:
         """Shutdown the exporter, flushing any remaining spans. Call before process exit."""

{aiqa_client-0.3.1 → aiqa_client-0.3.4}/aiqa/object_serialiser.py

@@ -6,9 +6,12 @@ Handles objects, dataclasses, circular references, and size limits.
 import json
 import os
 import dataclasses
+import logging
 from datetime import datetime, date, time
 from typing import Any, Callable, Set
 
+logger = logging.getLogger("aiqa")
+
 def toNumber(value: str|int|None) -> int:
     """Convert string to number. handling units like g, m, k, (also mb kb gb though these should be avoided)"""
     if value is None:
@@ -195,24 +198,39 @@ def object_to_dict(obj: Any, visited: Set[int], max_depth: int = 10, current_dep
         try:
             result = {}
             for k, v in obj.items():
-                key_str = str(k) if not isinstance(k, (str, int, float, bool)) else k
-                filtered_value = _apply_data_filters(key_str, v)
-                result[key_str] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
+                try:
+                    key_str = str(k) if not isinstance(k, (str, int, float, bool)) else k
+                    filtered_value = _apply_data_filters(key_str, v)
+                    result[key_str] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
+                except Exception as e:
+                    # If one key-value pair fails, log and use string representation for the value
+                    key_str = str(k) if not isinstance(k, (str, int, float, bool)) else k
+                    logger.debug(f"Failed to convert dict value for key '{key_str}': {e}")
+                    result[key_str] = safe_str_repr(v)
             visited.remove(obj_id)
             return result
-        except Exception:
+        except Exception as e:
             visited.discard(obj_id)
+            logger.debug(f"Failed to convert dict to dict: {e}")
             return safe_str_repr(obj)
     
     # Handle list/tuple
     if isinstance(obj, (list, tuple)):
         visited.add(obj_id)
         try:
-            result = [object_to_dict(item, visited, max_depth, current_depth + 1) for item in obj]
+            result = []
+            for item in obj:
+                try:
+                    result.append(object_to_dict(item, visited, max_depth, current_depth + 1))
+                except Exception as e:
+                    # If one item fails, log and use its string representation
+                    logger.debug(f"Failed to convert list item {type(item).__name__} to dict: {e}")
+                    result.append(safe_str_repr(item))
             visited.remove(obj_id)
             return result
-        except Exception:
+        except Exception as e:
             visited.discard(obj_id)
+            logger.debug(f"Failed to convert list/tuple to dict: {e}")
             return safe_str_repr(obj)
     
     # Handle dataclasses
@@ -221,13 +239,19 @@ def object_to_dict(obj: Any, visited: Set[int], max_depth: int = 10, current_dep
         try:
             result = {}
             for field in dataclasses.fields(obj):
-                value = getattr(obj, field.name, None)
-                filtered_value = _apply_data_filters(field.name, value)
-                result[field.name] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
+                try:
+                    value = getattr(obj, field.name, None)
+                    filtered_value = _apply_data_filters(field.name, value)
+                    result[field.name] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
+                except Exception as e:
+                    # If accessing a field fails, log and skip it
+                    logger.debug(f"Failed to access field {field.name} on {type(obj).__name__}: {e}")
+                    result[field.name] = "<error accessing field>"
             visited.remove(obj_id)
             return result
-        except Exception:
+        except Exception as e:
             visited.discard(obj_id)
+            logger.debug(f"Failed to convert dataclass {type(obj).__name__} to dict: {e}")
             return safe_str_repr(obj)
     
     # Handle objects with __dict__
@@ -242,8 +266,10 @@ def object_to_dict(obj: Any, visited: Set[int], max_depth: int = 10, current_dep
                     result[key] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
             visited.remove(obj_id)
             return result
-        except Exception:
+        except Exception as e:
             visited.discard(obj_id)
+            # Log the error for debugging, but still return string representation
+            logger.debug(f"Failed to convert object {type(obj).__name__} to dict: {e}")
             return safe_str_repr(obj)
     
     # Handle objects with __slots__
@@ -252,14 +278,20 @@ def object_to_dict(obj: Any, visited: Set[int], max_depth: int = 10, current_dep
         try:
             result = {}
             for slot in obj.__slots__:
-                if hasattr(obj, slot):
-                    value = getattr(obj, slot, None)
-                    filtered_value = _apply_data_filters(slot, value)
-                    result[slot] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
+                try:
+                    if hasattr(obj, slot):
+                        value = getattr(obj, slot, None)
+                        filtered_value = _apply_data_filters(slot, value)
+                        result[slot] = object_to_dict(filtered_value, visited, max_depth, current_depth + 1)
+                except Exception as e:
+                    # If accessing a slot fails, log and skip it
+                    logger.debug(f"Failed to access slot {slot} on {type(obj).__name__}: {e}")
+                    result[slot] = "<error accessing slot>"
             visited.remove(obj_id)
             return result
-        except Exception:
+        except Exception as e:
             visited.discard(obj_id)
+            logger.debug(f"Failed to convert slotted object {type(obj).__name__} to dict: {e}")
             return safe_str_repr(obj)
     
     # Fallback: try to get a few common attributes
@@ -301,14 +333,16 @@ def safe_json_dumps(value: Any) -> str:
     # across the whole object graph
     try:
         converted = object_to_dict(value, visited)
-    except Exception:
+    except Exception as e:
         # If conversion fails, try with a fresh visited set and json default handler
+        logger.debug(f"object_to_dict failed for {type(value).__name__}, trying json.dumps with default handler: {e}")
         try:
             json_str = json.dumps(value, default=json_default_handler_factory(set()))
             if len(json_str) > max_size_chars:
                 return f"<object {type(value)} too large: {len(json_str)} chars (limit: {max_size_chars} chars) begins: {json_str[:100]}... conversion error: {e}>"
             return json_str
-        except Exception:
+        except Exception as e2:
+            logger.debug(f"json.dumps with default handler also failed for {type(value).__name__}: {e2}")
             return safe_str_repr(value)
     
     # Try JSON serialization of the converted structure
@@ -318,7 +352,8 @@ def safe_json_dumps(value: Any) -> str:
         if len(json_str) > max_size_chars:
             return f"<object {type(value)} too large: {len(json_str)} chars (limit: {max_size_chars} chars) begins: {json_str[:100]}...>"
         return json_str
-    except Exception:
+    except Exception as e:
+        logger.debug(f"json.dumps total fail for {type(value).__name__}: {e2}")
         # Final fallback
         return safe_str_repr(value)
 

{aiqa_client-0.3.1 → aiqa_client-0.3.4/aiqa_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.3.1
+Version: 0.3.4
 Summary: OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server
 Author-email: AIQA <info@aiqa.dev>
 License: MIT

{aiqa_client-0.3.1 → aiqa_client-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiqa-client"
-version = "0.3.1"
+version = "0.3.4"
 description = "OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server"
 readme = "README.md"
 requires-python = ">=3.8"