aiqa-client 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

aiqa/__init__.py

@@ -13,7 +13,7 @@ from .tracing import (
     exporter,
 )
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 
 __all__ = [
     "WithTracing",

aiqa/aiqa_exporter.py

@@ -149,18 +149,65 @@ class AIQASpanExporter(SpanExporter):
         nanos = int(nanoseconds % 1_000_000_000)
         return (seconds, nanos)
 
+    def _build_request_headers(self) -> Dict[str, str]:
+        """Build HTTP headers for span requests."""
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"ApiKey {self.api_key}"
+        return headers
+
+    def _get_span_url(self) -> str:
+        """Get the URL for sending spans."""
+        if not self.server_url:
+            raise ValueError("AIQA_SERVER_URL is not set. Cannot send spans to server.")
+        return f"{self.server_url}/span"
+
+    def _is_interpreter_shutdown_error(self, error: Exception) -> bool:
+        """Check if error is due to interpreter shutdown."""
+        error_str = str(error)
+        return "cannot schedule new futures after" in error_str or "interpreter shutdown" in error_str
+
+    def _extract_spans_from_buffer(self) -> List[Dict[str, Any]]:
+        """Extract spans from buffer (thread-safe). Returns copy of buffer."""
+        with self.buffer_lock:
+            return self.buffer[:]
+
+    def _extract_and_remove_spans_from_buffer(self) -> List[Dict[str, Any]]:
+        """
+        Atomically extract and remove all spans from buffer (thread-safe).
+        Returns the extracted spans. This prevents race conditions where spans
+        are added between extraction and clearing.
+        """
+        with self.buffer_lock:
+            spans = self.buffer[:]
+            self.buffer.clear()
+            return spans
+
+    def _prepend_spans_to_buffer(self, spans: List[Dict[str, Any]]) -> None:
+        """
+        Prepend spans back to buffer (thread-safe). Used to restore spans
+        if sending fails.
+        """
+        with self.buffer_lock:
+            self.buffer[:0] = spans
+
+    def _clear_buffer(self) -> None:
+        """Clear the buffer (thread-safe)."""
+        with self.buffer_lock:
+            self.buffer.clear()
+
     async def flush(self) -> None:
         """
         Flush buffered spans to the server. Thread-safe: ensures only one flush operation runs at a time.
+        Atomically extracts spans to prevent race conditions with concurrent export() calls.
         """
         logger.debug("flush() called - attempting to acquire flush lock")
         with self.flush_lock:
             logger.debug("flush() acquired flush lock")
-            # Get current buffer and clear it atomically
-            with self.buffer_lock:
-                spans_to_flush = self.buffer[:]
-                self.buffer.clear()
-                logger.debug(f"flush() extracted {len(spans_to_flush)} span(s) from buffer")
+            # Atomically extract and remove spans to prevent race conditions
+            # where export() adds spans between extraction and clearing
+            spans_to_flush = self._extract_and_remove_spans_from_buffer()
+            logger.debug(f"flush() extracted {len(spans_to_flush)} span(s) from buffer")
 
             if not spans_to_flush:
                 logger.debug("flush() completed: no spans to flush")
@@ -171,14 +218,33 @@ class AIQASpanExporter(SpanExporter):
                 logger.warning(
                     f"Skipping flush: AIQA_SERVER_URL is not set. {len(spans_to_flush)} span(s) will not be sent."
                 )
+                # Spans already removed from buffer, nothing to clear
                 return
 
             logger.info(f"flush() sending {len(spans_to_flush)} span(s) to server")
             try:
                 await self._send_spans(spans_to_flush)
                 logger.info(f"flush() successfully sent {len(spans_to_flush)} span(s) to server")
+                # Spans already removed from buffer during extraction
+            except RuntimeError as error:
+                if self._is_interpreter_shutdown_error(error):
+                    if self.shutdown_requested:
+                        logger.debug(f"flush() skipped due to interpreter shutdown: {error}")
+                        # Put spans back for retry with sync send during shutdown
+                        self._prepend_spans_to_buffer(spans_to_flush)
+                    else:
+                        logger.warning(f"flush() interrupted by interpreter shutdown: {error}")
+                        # Put spans back for retry
+                        self._prepend_spans_to_buffer(spans_to_flush)
+                    raise
+                logger.error(f"Error flushing spans to server: {error}", exc_info=True)
+                # Put spans back for retry
+                self._prepend_spans_to_buffer(spans_to_flush)
+                raise
             except Exception as error:
                 logger.error(f"Error flushing spans to server: {error}", exc_info=True)
+                # Put spans back for retry
+                self._prepend_spans_to_buffer(spans_to_flush)
                 if self.shutdown_requested:
                     raise
 
@@ -211,17 +277,17 @@ class AIQASpanExporter(SpanExporter):
             
             logger.info(f"Auto-flush worker thread stopping (shutdown requested). Completed {cycle_count} cycles.")
             
-            # Final flush on shutdown
-            if self.shutdown_requested:
-                logger.info("Performing final flush on shutdown")
-                try:
-                    loop.run_until_complete(self.flush())
-                    logger.info("Final flush completed successfully")
-                except Exception as e:
-                    logger.error(f"Error in final flush: {e}", exc_info=True)
-                finally:
+            # Don't do final flush here - shutdown() will handle it with synchronous send
+            # This avoids event loop shutdown issues
+            logger.debug("Auto-flush thread skipping final flush (will be handled by shutdown() with sync send)")
+            
+            # Close the event loop
+            try:
+                if not loop.is_closed():
                     loop.close()
-                    logger.debug("Auto-flush worker thread event loop closed")
+                logger.debug("Auto-flush worker thread event loop closed")
+            except Exception:
+                pass  # Ignore errors during cleanup
 
         flush_thread = threading.Thread(target=flush_worker, daemon=True, name="AIQA-AutoFlush")
         flush_thread.start()
@@ -229,20 +295,13 @@ 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."""
-        if not self.server_url:
-            raise ValueError("AIQA_SERVER_URL is not set. Cannot send spans to server.")
-
+        """Send spans to the server API (async)."""
         import aiohttp
 
-        url = f"{self.server_url}/span"
+        url = self._get_span_url()
+        headers = self._build_request_headers()
         logger.debug(f"_send_spans() sending {len(spans)} spans to {url}")
-
-        headers = {
-            "Content-Type": "application/json",
-        }
         if self.api_key:
-            headers["Authorization"] = f"ApiKey {self.api_key[:10]}..."  # Log partial key for security
             logger.debug("_send_spans() using API key authentication")
         else:
             logger.debug("_send_spans() no API key provided")
@@ -250,11 +309,7 @@ class AIQASpanExporter(SpanExporter):
         try:
             async with aiohttp.ClientSession() as session:
                 logger.debug(f"_send_spans() POST request starting to {url}")
-                async with session.post(
-                    url,
-                    json=spans,
-                    headers=headers,
-                ) as response:
+                async with session.post(url, json=spans, headers=headers) as response:
                     logger.debug(f"_send_spans() received response: status={response.status}")
                     if not response.ok:
                         error_text = await response.text()
@@ -266,10 +321,48 @@ class AIQASpanExporter(SpanExporter):
                             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}", exc_info=True)
+            raise
         except Exception as e:
             logger.error(f"_send_spans() exception: {type(e).__name__}: {e}", exc_info=True)
             raise
 
+    def _send_spans_sync(self, spans: List[Dict[str, Any]]) -> None:
+        """Send spans to the server API (synchronous, for shutdown scenarios)."""
+        import requests
+
+        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}", exc_info=True)
+            raise
+
     def shutdown(self) -> None:
         """Shutdown the exporter, flushing any remaining spans. Call before process exit."""
         logger.info("shutdown() called - initiating exporter shutdown")
@@ -291,24 +384,32 @@ class AIQASpanExporter(SpanExporter):
         else:
             logger.debug("shutdown() no active auto-flush thread to wait for")
 
-        # Final flush attempt (synchronous)
-        import asyncio
-        try:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                logger.debug("shutdown() event loop is running, using ThreadPoolExecutor for final flush")
-                # If loop is running, schedule flush
-                import concurrent.futures
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(asyncio.run, self.flush())
-                    future.result(timeout=10.0)
+        # Final flush attempt (use synchronous send to avoid event loop issues)
+        with self.flush_lock:
+            logger.debug("shutdown() performing final flush with synchronous send")
+            # Atomically extract and remove spans to prevent race conditions
+            spans_to_flush = self._extract_and_remove_spans_from_buffer()
+            logger.debug(f"shutdown() extracted {len(spans_to_flush)} span(s) from buffer for final flush")
+
+            if spans_to_flush:
+                if not self.server_url:
+                    logger.warning(
+                        f"shutdown() skipping final flush: AIQA_SERVER_URL is not set. "
+                        f"{len(spans_to_flush)} span(s) will not be sent."
+                    )
+                    # Spans already removed from buffer
+                else:
+                    logger.info(f"shutdown() sending {len(spans_to_flush)} span(s) to server (synchronous)")
+                    try:
+                        self._send_spans_sync(spans_to_flush)
+                        logger.info(f"shutdown() successfully sent {len(spans_to_flush)} span(s) to server")
+                        # Spans already removed from buffer during extraction
+                    except Exception as e:
+                        logger.error(f"shutdown() failed to send spans: {e}", exc_info=True)
+                        # Spans already removed, but process is exiting anyway
+                        logger.warning(f"shutdown() {len(spans_to_flush)} span(s) were not sent due to error")
             else:
-                logger.debug("shutdown() event loop exists but not running, using run_until_complete")
-                loop.run_until_complete(self.flush())
-        except RuntimeError:
-            # No event loop, create one
-            logger.debug("shutdown() no event loop found, creating new one for final flush")
-            asyncio.run(self.flush())
+                logger.debug("shutdown() no spans to flush")
         
         # Check buffer state after shutdown
         with self.buffer_lock:

aiqa/tracing.py

@@ -175,8 +175,6 @@ def WithTracing(
         if is_async:
             @wraps(fn)
             async def async_traced_fn(*args, **kwargs):
-                span = tracer.start_span(fn_name)
-                
                 # Prepare input
                 input_data = _prepare_input(args, kwargs)
                 if filter_input:
@@ -186,41 +184,40 @@ def WithTracing(
                         if key in input_data:
                             del input_data[key]
                 
-                if input_data is not None:
-                    # Serialize for span attributes (OpenTelemetry only accepts primitives or JSON strings)
-                    serialized_input = _serialize_for_span(input_data)
-                    span.set_attribute("input", serialized_input)
-                
-                try:
-                    # Call the function within the span context
-                    trace_id = format(span.get_span_context().trace_id, "032x")
-                    logger.debug(f"do traceable stuff {fn_name} {trace_id}")
+                # Use start_as_current_span to ensure span is recorded by BatchSpanProcessor
+                with tracer.start_as_current_span(fn_name) as span:
+                    if input_data is not None:
+                        # Serialize for span attributes (OpenTelemetry only accepts primitives or JSON strings)
+                        serialized_input = _serialize_for_span(input_data)
+                        span.set_attribute("input", serialized_input)
                     
-                    with trace.use_span(span, end_on_exit=False):
+                    try:
+                        # Call the function within the span context
+                        trace_id = format(span.get_span_context().trace_id, "032x")
+                        logger.debug(f"do traceable stuff {fn_name} {trace_id}")
+                        
                         result = await fn(*args, **kwargs)
-                    
-                    # Prepare output
-                    output_data = result
-                    if filter_output:
-                        output_data = filter_output(output_data)                    
-                    if ignore_output and isinstance(output_data, dict):
-                        # Make a copy of output_data to avoid modifying the original
-                        output_data = output_data.copy()
-                        for key in ignore_output:
-                            if key in output_data:
-                                del output_data[key]
-                    
-                    span.set_attribute("output", _serialize_for_span(output_data))
-                    span.set_status(Status(StatusCode.OK))
-                    
-                    return result
-                except Exception as exception:
-                    error = exception if isinstance(exception, Exception) else Exception(str(exception))
-                    span.record_exception(error)
-                    span.set_status(Status(StatusCode.ERROR, str(error)))
-                    raise
-                finally:
-                    span.end()
+                        
+                        # Prepare output
+                        output_data = result
+                        if filter_output:
+                            output_data = filter_output(output_data)                    
+                        if ignore_output and isinstance(output_data, dict):
+                            # Make a copy of output_data to avoid modifying the original
+                            output_data = output_data.copy()
+                            for key in ignore_output:
+                                if key in output_data:
+                                    del output_data[key]
+                        
+                        span.set_attribute("output", _serialize_for_span(output_data))
+                        span.set_status(Status(StatusCode.OK))
+                        
+                        return result
+                    except Exception as exception:
+                        error = exception if isinstance(exception, Exception) else Exception(str(exception))
+                        span.record_exception(error)
+                        span.set_status(Status(StatusCode.ERROR, str(error)))
+                        raise
             
             async_traced_fn._is_traced = True
             logger.debug(f"Function {fn_name} is now traced (async)")
@@ -228,8 +225,6 @@ def WithTracing(
         else:
             @wraps(fn)
             def sync_traced_fn(*args, **kwargs):
-                span = tracer.start_span(fn_name)
-                
                 # Prepare input
                 input_data = _prepare_input(args, kwargs)
                 if filter_input:
@@ -239,41 +234,40 @@ def WithTracing(
                         if key in input_data:
                             del input_data[key]
                 
-                if input_data is not None:
-                    # Serialize for span attributes (OpenTelemetry only accepts primitives or JSON strings)
-                    serialized_input = _serialize_for_span(input_data)
-                    span.set_attribute("input", serialized_input)
-                
-                try:
-                    # Call the function within the span context
-                    trace_id = format(span.get_span_context().trace_id, "032x")
-                    logger.debug(f"do traceable stuff {fn_name} {trace_id}")
+                # Use start_as_current_span to ensure span is recorded by BatchSpanProcessor
+                with tracer.start_as_current_span(fn_name) as span:
+                    if input_data is not None:
+                        # Serialize for span attributes (OpenTelemetry only accepts primitives or JSON strings)
+                        serialized_input = _serialize_for_span(input_data)
+                        span.set_attribute("input", serialized_input)
                     
-                    with trace.use_span(span, end_on_exit=False):
+                    try:
+                        # Call the function within the span context
+                        trace_id = format(span.get_span_context().trace_id, "032x")
+                        logger.debug(f"do traceable stuff {fn_name} {trace_id}")
+                        
                         result = fn(*args, **kwargs)
-                    
-                    # Prepare output
-                    output_data = result
-                    if filter_output:
-                        output_data = filter_output(output_data)
-                    if ignore_output and isinstance(output_data, dict):
-                        # Make a copy of output_data to avoid modifying the original
-                        output_data = output_data.copy()
-                        for key in ignore_output:
-                            if key in output_data:
-                                del output_data[key]
-                    
-                    span.set_attribute("output", _serialize_for_span(output_data))
-                    span.set_status(Status(StatusCode.OK))
-                    
-                    return result
-                except Exception as exception:
-                    error = exception if isinstance(exception, Exception) else Exception(str(exception))
-                    span.record_exception(error)
-                    span.set_status(Status(StatusCode.ERROR, str(error)))
-                    raise
-                finally:
-                    span.end()
+                        
+                        # Prepare output
+                        output_data = result
+                        if filter_output:
+                            output_data = filter_output(output_data)
+                        if ignore_output and isinstance(output_data, dict):
+                            # Make a copy of output_data to avoid modifying the original
+                            output_data = output_data.copy()
+                            for key in ignore_output:
+                                if key in output_data:
+                                    del output_data[key]
+                        
+                        span.set_attribute("output", _serialize_for_span(output_data))
+                        span.set_status(Status(StatusCode.OK))
+                        
+                        return result
+                    except Exception as exception:
+                        error = exception if isinstance(exception, Exception) else Exception(str(exception))
+                        span.record_exception(error)
+                        span.set_status(Status(StatusCode.ERROR, str(error)))
+                        raise
             
             sync_traced_fn._is_traced = True
             logger.debug(f"Function {fn_name} is now traced (sync)")
@@ -305,7 +299,7 @@ def set_span_name(span_name: str) -> bool:
     """
     span = trace.get_current_span()
     if span and span.is_recording():
-        span.set_name(span_name)
+        span.update_name(span_name)
         return True
     return False
 

{aiqa_client-0.1.1.dist-info → aiqa_client-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.1.1
+Version: 0.1.3
 Summary: OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server
 Author-email: AIQA <info@aiqa.dev>
 License: MIT
@@ -27,6 +27,7 @@ Requires-Dist: opentelemetry-api>=1.24.0
 Requires-Dist: opentelemetry-sdk>=1.24.0
 Requires-Dist: opentelemetry-semantic-conventions>=0.40b0
 Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"

aiqa_client-0.1.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+aiqa/__init__.py,sha256=mQWkldjxytAru66UBU5aRiENpR9hPsqxY5FBSqLwS60,470
+aiqa/aiqa_exporter.py,sha256=vXyX6Q_iOjrDz3tCPOMXuBTQg7ocACdOOqzpkUqhy9g,19131
+aiqa/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiqa/tracing.py,sha256=TnKkasn9ESofNMzztTMAOhs_OfD6WZj1KS1U2Ikbypk,12084
+aiqa_client-0.1.3.dist-info/licenses/LICENSE,sha256=kIzkzLuzG0HHaWYm4F4W5FeJ1Yxut3Ec6bhLWyw798A,1062
+aiqa_client-0.1.3.dist-info/METADATA,sha256=lqRVBC0F7vbpeC0akkvRcn_c84vkwTLuwCzX6FTzpDs,3772
+aiqa_client-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiqa_client-0.1.3.dist-info/top_level.txt,sha256=nwcsuVVSuWu27iLxZd4n1evVzv1W6FVTrSnCXCc-NQs,5
+aiqa_client-0.1.3.dist-info/RECORD,,

aiqa_client-0.1.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-aiqa/__init__.py,sha256=LEONMsfGaQXePRZN9XxdULWsufbfJnTJ1t1-LU9c-9o,470
-aiqa/aiqa_exporter.py,sha256=Y0VrZqnb3LG4WSb9XQYct9ABwunG04T9aM8I6EH0qQQ,13781
-aiqa/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiqa/tracing.py,sha256=RwcHk9P_dKoQUv545VVHqnJ4x8jaZkqA4YhdVUXGywc,11889
-aiqa_client-0.1.1.dist-info/licenses/LICENSE,sha256=kIzkzLuzG0HHaWYm4F4W5FeJ1Yxut3Ec6bhLWyw798A,1062
-aiqa_client-0.1.1.dist-info/METADATA,sha256=NcmuXu5XyQsq2X-MRn_qaq4pCgnwH-1khBuZruYAwKQ,3740
-aiqa_client-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiqa_client-0.1.1.dist-info/top_level.txt,sha256=nwcsuVVSuWu27iLxZd4n1evVzv1W6FVTrSnCXCc-NQs,5
-aiqa_client-0.1.1.dist-info/RECORD,,