aiqa-client 0.1.0__tar.gz → 0.1.1__tar.gz

{aiqa_client-0.1.0/aiqa_client.egg-info → aiqa_client-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.1.0
+Version: 0.1.1
 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.1.0 → aiqa_client-0.1.1}/aiqa/__init__.py

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

{aiqa_client-0.1.0 → aiqa_client-0.1.1}/aiqa/aiqa_exporter.py

@@ -43,6 +43,11 @@ class AIQASpanExporter(SpanExporter):
         self.flush_lock = threading.Lock()
         self.shutdown_requested = False
         self.flush_timer: Optional[threading.Thread] = None
+        
+        logger.info(
+            f"Initializing AIQASpanExporter: server_url={self.server_url or 'not set'}, "
+            f"flush_interval={flush_interval_seconds}s"
+        )
         self._start_auto_flush()
 
     @property
@@ -58,12 +63,19 @@ class AIQASpanExporter(SpanExporter):
         Export spans to the AIQA server. Adds spans to buffer for async flushing.
         """
         if not spans:
+            logger.debug("export() called with empty spans list")
             return SpanExportResult.SUCCESS
 
         # Serialize and add to buffer
         with self.buffer_lock:
             serialized_spans = [self._serialize_span(span) for span in spans]
             self.buffer.extend(serialized_spans)
+            buffer_size = len(self.buffer)
+        
+        logger.debug(
+            f"export() added {len(spans)} span(s) to buffer. "
+            f"Total buffered: {buffer_size}"
+        )
 
         return SpanExportResult.SUCCESS
 
@@ -141,13 +153,17 @@ class AIQASpanExporter(SpanExporter):
         """
         Flush buffered spans to the server. Thread-safe: ensures only one flush operation runs at a time.
         """
+        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")
 
             if not spans_to_flush:
+                logger.debug("flush() completed: no spans to flush")
                 return
 
             # Skip sending if server URL is not configured
@@ -157,43 +173,60 @@ class AIQASpanExporter(SpanExporter):
                 )
                 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")
             except Exception as error:
-                logger.error(f"Error flushing spans to server: {error}")
+                logger.error(f"Error flushing spans to server: {error}", exc_info=True)
                 if self.shutdown_requested:
                     raise
 
     def _start_auto_flush(self) -> None:
         """Start the auto-flush timer."""
         if self.shutdown_requested:
+            logger.warning("_start_auto_flush() called but shutdown already requested")
             return
 
+        logger.info(f"Starting auto-flush thread with interval {self.flush_interval_ms / 1000.0}s")
+
         def flush_worker():
             import asyncio
+            logger.debug("Auto-flush worker thread started")
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
             
+            cycle_count = 0
             while not self.shutdown_requested:
+                cycle_count += 1
+                logger.debug(f"Auto-flush cycle #{cycle_count} starting")
                 try:
                     loop.run_until_complete(self.flush())
+                    logger.debug(f"Auto-flush cycle #{cycle_count} completed, sleeping {self.flush_interval_ms / 1000.0}s")
                     time.sleep(self.flush_interval_ms / 1000.0)
                 except Exception as e:
-                    logger.error(f"Error in auto-flush: {e}")
+                    logger.error(f"Error in auto-flush cycle #{cycle_count}: {e}", exc_info=True)
+                    logger.debug(f"Auto-flush cycle #{cycle_count} error handled, sleeping {self.flush_interval_ms / 1000.0}s")
                     time.sleep(self.flush_interval_ms / 1000.0)
             
+            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}")
+                    logger.error(f"Error in final flush: {e}", exc_info=True)
                 finally:
                     loop.close()
+                    logger.debug("Auto-flush worker thread event loop closed")
 
-        flush_thread = threading.Thread(target=flush_worker, daemon=True)
+        flush_thread = threading.Thread(target=flush_worker, daemon=True, name="AIQA-AutoFlush")
         flush_thread.start()
         self.flush_timer = flush_thread
+        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."""
@@ -202,47 +235,88 @@ class AIQASpanExporter(SpanExporter):
 
         import aiohttp
 
-        logger.debug(f"Sending {len(spans)} spans to server: {self.server_url}")
+        url = f"{self.server_url}/span"
+        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}"
-
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.server_url}/span",
-                json=spans,
-                headers=headers,
-            ) as response:
-                if not response.ok:
-                    error_text = await response.text()
-                    raise Exception(
-                        f"Failed to send spans: {response.status} {response.reason} - {error_text}"
-                    )
+            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")
+
+        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:
+                    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 Exception as e:
+            logger.error(f"_send_spans() 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")
         self.shutdown_requested = True
 
+        # Check buffer state before shutdown
+        with self.buffer_lock:
+            buffer_size = len(self.buffer)
+            logger.info(f"shutdown() buffer contains {buffer_size} span(s) before shutdown")
+
         # Wait for flush thread to finish (it will do final flush)
         if self.flush_timer and self.flush_timer.is_alive():
+            logger.info("shutdown() waiting for auto-flush thread to complete (timeout=10s)")
             self.flush_timer.join(timeout=10.0)
+            if self.flush_timer.is_alive():
+                logger.warning("shutdown() auto-flush thread did not complete within timeout")
+            else:
+                logger.info("shutdown() auto-flush thread completed")
+        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)
             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())
+        
+        # Check buffer state after shutdown
+        with self.buffer_lock:
+            buffer_size = len(self.buffer)
+            if buffer_size > 0:
+                logger.warning(f"shutdown() buffer still contains {buffer_size} span(s) after shutdown")
+            else:
+                logger.info("shutdown() buffer is empty after shutdown")
+        
+        logger.info("shutdown() completed")
 

{aiqa_client-0.1.0 → aiqa_client-0.1.1}/aiqa/tracing.py

@@ -181,9 +181,10 @@ def WithTracing(
                 input_data = _prepare_input(args, kwargs)
                 if filter_input:
                     input_data = filter_input(input_data)
-                if ignore_input and isinstance(input_data, dict):
-                    # TODO: implement ignore_input logic
-                    pass
+                if ignore_input and isinstance(input_data, dict):                    
+                    for key in ignore_input:
+                        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)
@@ -201,10 +202,13 @@ def WithTracing(
                     # Prepare output
                     output_data = result
                     if filter_output:
-                        output_data = filter_output(output_data)
+                        output_data = filter_output(output_data)                    
                     if ignore_output and isinstance(output_data, dict):
-                        # TODO: implement ignore_output logic
-                        pass
+                        # 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))
@@ -231,8 +235,9 @@ def WithTracing(
                 if filter_input:
                     input_data = filter_input(input_data)
                 if ignore_input and isinstance(input_data, dict):
-                    # TODO: implement ignore_input logic
-                    pass
+                    for key in ignore_input:
+                        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)
@@ -252,8 +257,11 @@ def WithTracing(
                     if filter_output:
                         output_data = filter_output(output_data)
                     if ignore_output and isinstance(output_data, dict):
-                        # TODO: implement ignore_output logic
-                        pass
+                        # 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))

{aiqa_client-0.1.0 → aiqa_client-0.1.1/aiqa_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.1.0
+Version: 0.1.1
 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.1.0 → aiqa_client-0.1.1}/pyproject.toml

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