[QUO-869] Update logger to be non blocking (#73)

* update to be non blocking

* restore url

* pr feedback

* remove logs

* Remove thread pool exec

* name

* dequeue

Author: mike-goitia

examples/logging/async_simple_logging.py

@@ -11,14 +11,15 @@
     tags={"model": "gpt-4o", "feature": "customer-support"},
     hallucination_detection=True,
     inconsistency_detection=True,
+    sample_rate=1.0,
 )
 
 
 async def main():
     # Mock retrieved documents
     retrieved_documents = [{"page_content": "Sample document"}]
 
-    response = await quotient_logger.log(
+    await quotient_logger.log(
         user_query="Sample input",
         model_output="Sample output",
         # Page content from Documents from your retriever used to generate the model output
@@ -38,7 +39,14 @@ async def main():
         tags={"model": "gpt-4o-mini", "feature": "customer-support"},
     )
 
-    print(response)
+    print("Log request sent")
+    print("Press Enter to exit...")
+
+    # Use asyncio's run_in_executor to handle blocking input() call
+    loop = asyncio.get_running_loop()
+    await loop.run_in_executor(None, input)
+
+    print("Exiting...")
 
 
 # Run the async function

examples/logging/example_fast_api/README.md

@@ -0,0 +1,21 @@
+# FastAPI Example with Quotient Logging
+
+This example demonstrates how to use Quotient's logging capabilities with a FastAPI application.
+
+## Installation
+
+Install the Quotient Python package as an editable pip package:
+
+```bash
+pip install -e ../../../../quotient-python
+```
+
+## Running the Application
+
+Start the FastAPI application with Uvicorn:
+
+```bash
+uvicorn main:app --reload
+```
+
+This will start the server with hot-reloading enabled for development. 

examples/logging/example_fast_api/constants.py

@@ -13,11 +13,18 @@
 ### Instructions
 {{instructions}}
 """
+# Documents that may contain context that model output can be attributed to
 RETRIEVED_DOCUMENTS = [
     {
         "page_content": "Our company has unlimited vacation days",
         "metadata": {"document_id": "123"},
     }
 ]
 QUESTION = "What is the company's vacation policy?"
+# System instructions that may contain context that model output can be attributed to
 INSTRUCTIONS = ["If you do not know the answer, just say that you do not know."]
+# Historical messages that may contain context that model output can be attributed to
+MESSAGE_HISTORY = [
+    {"role": "user", "content": "What is the company's vacation policy?"},
+    {"role": "assistant", "content": "Our company has unlimited vacation days"},
+]

examples/logging/example_fast_api/log.py

@@ -5,7 +5,13 @@
 from openai import OpenAI, AsyncOpenAI
 from quotientai import QuotientAI, AsyncQuotientAI
 
-from constants import INSTRUCTIONS, RETRIEVED_DOCUMENTS, QUESTION, PROMPT, INSTRUCTIONS
+from constants import (
+    INSTRUCTIONS,
+    RETRIEVED_DOCUMENTS,
+    QUESTION,
+    PROMPT,
+    MESSAGE_HISTORY,
+)
 
 # Load environment variables
 load_dotenv()
@@ -19,23 +25,27 @@
 ########################################################
 # Initialize QuotientAI and QuotientAI Logger
 ########################################################
-quotient = QuotientAI()
+quotient = QuotientAI(api_key=os.environ.get("QUOTIENT_API_KEY"))
 quotient_logger = quotient.logger.init(
     app_name="my-app",
     environment="dev",
     tags={"model": "gpt-4o", "feature": "customer-support"},
     hallucination_detection=True,
+    hallucination_detection_sample_rate=0.0,
+    sample_rate=1.0,
 )
 
 ########################################################
 # Initialize Async QuotientAI Logger
 ########################################################
-async_quotient = AsyncQuotientAI()
+async_quotient = AsyncQuotientAI(api_key=os.environ.get("QUOTIENT_API_KEY"))
 quotient_async_logger = async_quotient.logger.init(
     app_name="my-app",
     environment="dev",
     tags={"model": "gpt-4o", "feature": "customer-support"},
     hallucination_detection=True,
+    hallucination_detection_sample_rate=0.0,
+    sample_rate=1.0,
 )
 
 
@@ -45,7 +55,12 @@ def create_log():
     Create a log for the model completion using BackgroundTasks to create the log in the background
     """
     formatted_prompt = chevron.render(
-        PROMPT, {"context": RETRIEVED_DOCUMENTS, "question": QUESTION, "instructions": INSTRUCTIONS}
+        PROMPT,
+        {
+            "context": RETRIEVED_DOCUMENTS,
+            "question": QUESTION,
+            "instructions": INSTRUCTIONS,
+        },
     )
 
     response = client.chat.completions.create(
@@ -70,6 +85,7 @@ def create_log():
         model_output=model_output,
         documents=document_contents,
         instructions=INSTRUCTIONS,
+        message_history=MESSAGE_HISTORY,
     )
 
     return {"response": model_output}
@@ -78,7 +94,12 @@ def create_log():
 @router.post("/create-log-async/")
 async def create_log_async():
     formatted_prompt = chevron.render(
-        PROMPT, {"context": RETRIEVED_DOCUMENTS, "question": QUESTION, "instructions": INSTRUCTIONS}
+        PROMPT,
+        {
+            "context": RETRIEVED_DOCUMENTS,
+            "question": QUESTION,
+            "instructions": INSTRUCTIONS,
+        },
     )
 
     response = await async_client.chat.completions.create(
@@ -103,6 +124,7 @@ async def create_log_async():
         model_output=model_output,
         documents=document_contents,
         instructions=INSTRUCTIONS,
+        message_history=MESSAGE_HISTORY,
     )
 
     return {"response": model_output}

examples/logging/example_fast_api/main.py

@@ -1,6 +1,17 @@
 from fastapi import FastAPI
 from log import router as log_router
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
 
 app = FastAPI()
 
+app.title = "QuotientAI Logger Testing"
+app.description = "A simple API for testing logging and detection with QuotientAI"
+
 app.include_router(log_router)

examples/logging/simple_logging.py

@@ -14,7 +14,7 @@
 # Mock retrieved documents
 retrieved_documents = [{"page_content": "Sample document"}]
 
-response = quotient_logger.log(
+quotient_logger.log(
     user_query="Sample input",
     model_output="Sample output",
     # Page content from Documents from your retriever used to generate the model output
@@ -34,4 +34,4 @@
     tags={"model": "gpt-4o-mini", "feature": "customer-support"},
 )
 
-print(response)
+print("Log created")

quotientai/async_client.py

@@ -1,4 +1,5 @@
 import os
+import random
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -19,10 +20,12 @@ def __init__(self, api_key: str):
         )
 
     @handle_async_errors
-    async def _get(self, path: str, params: Optional[Dict[str, Any]] = None, timeout: int = None) -> dict:
+    async def _get(
+        self, path: str, params: Optional[Dict[str, Any]] = None, timeout: int = None
+    ) -> dict:
         """
         Send an async GET request to the specified path.
-        
+
         Args:
             path: API endpoint path
             params: Optional query parameters
@@ -73,6 +76,7 @@ def __init__(self, logs_resource):
         self.app_name: Optional[str] = None
         self.environment: Optional[str] = None
         self.tags: Dict[str, Any] = {}
+        self.sample_rate: float = 1.0
         self.hallucination_detection: bool = False
         self.inconsistency_detection: bool = False
         self._configured = False
@@ -84,6 +88,7 @@ def init(
         app_name: str,
         environment: str,
         tags: Optional[Dict[str, Any]] = {},
+        sample_rate: float = 1.0,
         hallucination_detection: bool = False,
         inconsistency_detection: bool = False,
         hallucination_detection_sample_rate: float = 0,
@@ -95,12 +100,23 @@ def init(
         self.app_name = app_name
         self.environment = environment
         self.tags = tags or {}
+        self.sample_rate = sample_rate
+
+        if not (0.0 <= self.sample_rate <= 1.0):
+            raise QuotientAIError("sample_rate must be between 0.0 and 1.0")
+
         self.hallucination_detection = hallucination_detection
         self.inconsistency_detection = inconsistency_detection
         self._configured = True
         self.hallucination_detection_sample_rate = hallucination_detection_sample_rate
         return self
 
+    def _should_sample(self) -> bool:
+        """
+        Determine if the log should be sampled based on the sample rate.
+        """
+        return random.random() < self.sample_rate
+
     async def log(
         self,
         *,
@@ -139,21 +155,22 @@ async def log(
             else self.inconsistency_detection
         )
 
-        log = await self.logs_resource.create(
-            app_name=self.app_name,
-            environment=self.environment,
-            user_query=user_query,
-            model_output=model_output,
-            documents=documents,
-            message_history=message_history,
-            instructions=instructions,
-            tags=merged_tags,
-            hallucination_detection=hallucination_detection,
-            inconsistency_detection=inconsistency_detection,
-            hallucination_detection_sample_rate=self.hallucination_detection_sample_rate,
-        )
+        if self._should_sample():
+            await self.logs_resource.create(
+                app_name=self.app_name,
+                environment=self.environment,
+                user_query=user_query,
+                model_output=model_output,
+                documents=documents,
+                message_history=message_history,
+                instructions=instructions,
+                tags=merged_tags,
+                hallucination_detection=hallucination_detection,
+                inconsistency_detection=inconsistency_detection,
+                hallucination_detection_sample_rate=self.hallucination_detection_sample_rate,
+            )
 
-        return log
+        return None
 
 
 class AsyncQuotientAI:

quotientai/client.py

@@ -20,7 +20,9 @@ def __init__(self, api_key: str):
         )
 
     @handle_errors
-    def _get(self, path: str, params: Optional[Dict[str, Any]] = None, timeout: int = None) -> dict:
+    def _get(
+        self, path: str, params: Optional[Dict[str, Any]] = None, timeout: int = None
+    ) -> dict:
         """
         Send a GET request to the specified path.
 
@@ -154,7 +156,7 @@ def log(
         )
 
         if self._should_sample():
-            log = self.logs_resource.create(
+            self.logs_resource.create(
                 app_name=self.app_name,
                 environment=self.environment,
                 user_query=user_query,
@@ -168,7 +170,7 @@ def log(
                 hallucination_detection_sample_rate=self.hallucination_detection_sample_rate,
             )
 
-            return log
+            return None
         else:
             return None