pyquerytracker 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

examples/async_example.py

@@ -0,0 +1,63 @@
+import asyncio
+import os
+import sys
+
+from pyquerytracker import TrackQuery
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+
+# Example 1: Basic async function
+@TrackQuery()
+async def fetch_data():
+    await asyncio.sleep(0.2)
+    return "fetched data"
+
+
+# Example 2: Async function with parameters
+@TrackQuery()
+async def compute_sum(a, b):
+    await asyncio.sleep(0.1)
+    return a + b
+
+
+# Example 3: Class method async tracking
+class DatabaseService:
+    @TrackQuery()
+    async def query_users(self):
+        await asyncio.sleep(0.3)
+        return ["Alice", "Bob", "Charlie"]
+
+
+# Example 4: Async function that raises an error
+@TrackQuery()
+async def fail_fast():
+    await asyncio.sleep(0.05)
+    raise RuntimeError("Database failure simulation")
+
+
+# Example 5: Async function with slow duration to trigger logging thresholds
+@TrackQuery()
+async def slow_operation():
+    await asyncio.sleep(0.5)
+    return "slow complete"
+
+
+# Run all examples
+async def main():
+    print("Example 1: fetch_data →", await fetch_data())
+    print("Example 2: compute_sum(5, 7) →", await compute_sum(5, 7))
+
+    service = DatabaseService()
+    print("Example 3: query_users →", await service.query_users())
+
+    try:
+        await fail_fast()
+    except RuntimeError as e:
+        print("Example 4: fail_fast → raised:", e)
+
+    print("Example 5: slow_operation →", await slow_operation())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/core/async_usage.py

@@ -0,0 +1,53 @@
+import asyncio
+import logging
+
+from pyquerytracker import TrackQuery, configure
+
+# Configure logging to see the output
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+# Set a low threshold to easily see "slow" logs
+configure(slow_log_threshold_ms=150, slow_log_level=logging.WARNING)
+
+
+@TrackQuery()
+async def fast_async_query():
+    """An async function that executes quickly."""
+    await asyncio.sleep(0.1)
+    return "Fast async query completed"
+
+
+@TrackQuery()
+async def slow_async_query():
+    """An async function that takes longer to execute."""
+    await asyncio.sleep(0.2)
+    return "Slow async query completed"
+
+
+@TrackQuery()
+async def failing_async_query():
+    """An async function that raises an error."""
+    await asyncio.sleep(0.1)
+    raise ConnectionError("Could not connect to async database")
+
+
+async def main():
+    print("--- Testing fast async query (should be INFO log) ---")
+    result1 = await fast_async_query()
+    print(f"Result: {result1}\n")
+
+    print("--- Testing slow async query (should be WARNING log) ---")
+    result2 = await slow_async_query()
+    print(f"Result: {result2}\n")
+
+    print("--- Testing failing async query (should be ERROR log) ---")
+    try:
+        await failing_async_query()
+    except ConnectionError as e:
+        print(f"Caught expected error: {e}\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/core/basic_usage.py

@@ -0,0 +1,17 @@
+from pyquerytracker import TrackQuery, configure
+
+configure(slow_log_threshold_ms=1000, slow_log_level=20)
+
+
+@TrackQuery()
+def simple_query():
+    """A simple function that simulates a database query."""
+    import time
+
+    time.sleep(0.5)  # Simulate some work
+    return "Query completed successfully"
+
+
+if __name__ == "__main__":
+    result = simple_query()
+    print(f"Result: {result}")

examples/core/error_handling.py

@@ -0,0 +1,24 @@
+import logging
+
+from pyquerytracker import TrackQuery
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+
+@TrackQuery()
+def failing_query():
+    """A function that simulates a failed database query."""
+    import time
+
+    time.sleep(0.3)  # Simulate some work
+    raise ValueError("Database connection failed")
+
+
+if __name__ == "__main__":
+    try:
+        failing_query()
+    except ValueError as e:
+        print(f"Caught expected error: {e}")

examples/core/quick_test.py

@@ -0,0 +1,39 @@
+import time
+
+from pyquerytracker import TrackQuery
+
+
+@TrackQuery()
+def fast_query():
+    """A function that executes quickly."""
+    return "Fast query completed"
+
+
+@TrackQuery()
+def slow_query():
+    """A function that takes some time to execute."""
+    time.sleep(0.5)  # Simulate some work
+    return "Slow query completed"
+
+
+@TrackQuery()
+def failing_query():
+    """A function that raises an error."""
+    time.sleep(0.2)  # Simulate some work
+    raise ValueError("Query failed!")
+
+
+if __name__ == "__main__":
+    print("\nTesting fast query:")
+    result1 = fast_query()
+    print(f"Result: {result1}")
+
+    print("\nTesting slow query:")
+    result2 = slow_query()
+    print(f"Result: {result2}")
+
+    print("\nTesting failing query:")
+    try:
+        failing_query()
+    except ValueError as e:
+        print(f"Caught expected error: {e}")

examples/core/with_arguments.py

@@ -0,0 +1,27 @@
+import logging
+
+from pyquerytracker import TrackQuery
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+
+@TrackQuery()
+def complex_query(user_id: int, query_type: str, limit: int = 10):
+    """A function that simulates a complex database query with arguments."""
+    import time
+
+    time.sleep(0.2)  # Simulate some work
+    return f"Retrieved {limit} {query_type} records for user {user_id}"
+
+
+if __name__ == "__main__":
+    # Test with positional arguments
+    result1 = complex_query(123, "posts")
+    print(f"Result 1: {result1}")
+
+    # Test with keyword arguments
+    result2 = complex_query(user_id=456, query_type="comments", limit=5)
+    print(f"Result 2: {result2}")

examples/core/with_config.py

@@ -0,0 +1,30 @@
+import logging
+import time
+
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import configure
+
+configure(slow_log_threshold_ms=640, slow_log_level=logging.ERROR)
+
+
+@TrackQuery()
+def fast_query():
+    """A function that executes quickly."""
+    return "Fast query completed"
+
+
+@TrackQuery()
+def slow_query():
+    """A function that takes some time to execute."""
+    time.sleep(0.3)  # Simulate some work
+    return "Slow query completed"
+
+
+if __name__ == "__main__":
+    # Test with positional arguments
+    result1 = fast_query()
+    print(f"Result 1: {result1}")
+
+    # Test with keyword arguments
+    result2 = slow_query()
+    print(f"Result 2: {result2}")

examples/exporter/csv_exporter_1.py

@@ -0,0 +1,36 @@
+import os
+import time
+
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import ExportType, configure
+
+os.makedirs("logs-csv", exist_ok=True)
+
+configure(
+    slow_log_threshold_ms=50.0,
+    slow_log_level=20,  # INFO
+    export_type=ExportType.CSV,
+    export_path="logs-csv/query_logs_2.csv",
+)
+
+
+@TrackQuery()
+def process_data(x, y):
+    time.sleep(8)
+    return x + y
+
+
+@TrackQuery()
+def failing_task():
+    time.sleep(0.03)  # not slow
+    raise RuntimeError("This failed intentionally.")
+
+
+# Run tasks
+print("Result:", process_data(5, 7))
+print("Result:", process_data(1, 2))
+
+try:
+    failing_task()
+except Exception:
+    pass

examples/exporter/json_exporter.py

@@ -0,0 +1,36 @@
+import os
+import time
+
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import ExportType, configure
+
+os.makedirs("logs-json", exist_ok=True)
+
+configure(
+    slow_log_threshold_ms=50.0,
+    slow_log_level=20,  # INFO
+    export_type=ExportType.JSON,
+    export_path="logs-json/query_logs.json",
+)
+
+
+@TrackQuery()
+def process_data(x, y):
+    time.sleep(0.08)  # triggers slow log
+    return x + y
+
+
+@TrackQuery()
+def failing_task():
+    time.sleep(0.03)  # not slow
+    raise RuntimeError("This failed intentionally.")
+
+
+# Run tasks
+print("Result:", process_data(5, 7))
+print("Result:", process_data(1, 2))
+
+try:
+    failing_task()
+except Exception:
+    pass

examples/fastapi_app.py

@@ -0,0 +1,119 @@
+import asyncio
+import random
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pyquerytracker import monitor_queries, configure, StatsCollector
+
+# Initialize StatsCollector globally
+stats_collector = StatsCollector()
+
+# Configure pyquerytracker
+configure(
+    default_threshold_ms=500,  # Set threshold to 500ms
+    json_export_enabled=True,
+    json_export_path="query_stats.json"
+)
+
+app = FastAPI(title="PyQueryTracker Demo")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@monitor_queries(threshold_ms=300)
+async def fast_query():
+    """A query that should be under threshold"""
+    await asyncio.sleep(0.1)  # 100ms
+    return {"status": "success", "message": "Fast query completed"}
+
+@monitor_queries(threshold_ms=300)
+async def slow_query():
+    """A query that should exceed threshold"""
+    await asyncio.sleep(0.4)  # 400ms
+    return {"status": "success", "message": "Slow query completed"}
+
+@monitor_queries(threshold_ms=300)
+async def error_query():
+    """A query that will raise an error"""
+    await asyncio.sleep(0.2)  # 200ms
+    raise HTTPException(status_code=500, detail="Simulated error")
+
+@app.get("/fast")
+async def get_fast():
+    """Endpoint that executes a fast query"""
+    try:
+        result = await fast_query()
+        return JSONResponse(
+            content=result,
+            media_type="application/json"
+        )
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)},
+            media_type="application/json"
+        )
+
+@app.get("/slow")
+async def get_slow():
+    """Endpoint that executes a slow query"""
+    try:
+        result = await slow_query()
+        return JSONResponse(
+            content=result,
+            media_type="application/json"
+        )
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)},
+            media_type="application/json"
+        )
+
+@app.get("/error")
+async def get_error():
+    """Endpoint that executes a query that will error"""
+    try:
+        await error_query()
+    except HTTPException as e:
+        return JSONResponse(
+            status_code=e.status_code,
+            content={"error": e.detail},
+            media_type="application/json"
+        )
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)},
+            media_type="application/json"
+        )
+
+@app.get("/random")
+async def get_random():
+    """Endpoint with random response time"""
+    try:
+        delay = random.uniform(0.1, 0.5)
+        await asyncio.sleep(delay)
+        return JSONResponse(
+            content={
+                "status": "success",
+                "message": f"Random query completed in {delay:.2f}s"
+            },
+            media_type="application/json"
+        )
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)},
+            media_type="application/json"
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8080) 

examples/test_endpoints.py

@@ -0,0 +1,73 @@
+import asyncio
+import aiohttp
+import time
+from pyquerytracker.cli import report
+from pyquerytracker.decorator import monitor_queries
+
+async def test_endpoint(session: aiohttp.ClientSession, endpoint: str, expected_status: int = 200) -> None:
+    """Test an endpoint and print the result"""
+    try:
+        async with session.get(f"http://localhost:8000{endpoint}") as response:
+            if response.status == expected_status:
+                data = await response.json()
+                print(f"Success testing {endpoint}: {data}")
+            else:
+                error_text = await response.text()
+                print(f"Error testing {endpoint}: {response.status}, {error_text}")
+    except Exception as e:
+        print(f"Error testing {endpoint}: {str(e)}")
+
+@monitor_queries(name="test_fast")
+async def test_fast(session: aiohttp.ClientSession) -> None:
+    """Test the fast endpoint"""
+    await test_endpoint(session, "/fast")
+
+@monitor_queries(name="test_slow")
+async def test_slow(session: aiohttp.ClientSession) -> None:
+    """Test the slow endpoint"""
+    await test_endpoint(session, "/slow")
+
+@monitor_queries(name="test_error")
+async def test_error(session: aiohttp.ClientSession) -> None:
+    """Test the error endpoint"""
+    await test_endpoint(session, "/error", expected_status=500)
+
+@monitor_queries(name="test_random")
+async def test_random(session: aiohttp.ClientSession) -> None:
+    """Test the random endpoint"""
+    await test_endpoint(session, "/random")
+
+async def main():
+    """Main test function"""
+    async with aiohttp.ClientSession() as session:
+        # Test fast endpoint multiple times
+        for _ in range(15):
+            await test_fast(session)
+        
+        # Test random endpoint
+        for _ in range(10):
+            await test_random(session)
+        
+        # Test error endpoint
+        for _ in range(15):
+            await test_error(session)
+        
+        # Test random endpoint again
+        for _ in range(10):
+            await test_random(session)
+        
+        # Test slow endpoint
+        for _ in range(20):
+            await test_slow(session)
+        
+        # Test random endpoint one more time
+        for _ in range(10):
+            await test_random(session)
+
+if __name__ == "__main__":
+    # Run tests
+    asyncio.run(main())
+    
+    # Generate report
+    print("\nGenerating statistics report...")
+    report() 

pyquerytracker/__init__.py

@@ -1,4 +1,5 @@
-from .core import TrackQuery
 from .config import configure
+from .core import TrackQuery
+from .api import app
 
-__all__ = ["TrackQuery", "configure"]
+__all__ = ["TrackQuery", "configure", "app"]

pyquerytracker/api.py

@@ -0,0 +1,72 @@
+from datetime import datetime, timedelta
+
+from fastapi import FastAPI, Query, Request, WebSocket
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from pyquerytracker.config import get_config
+from pyquerytracker.db.models import TrackedQuery
+from pyquerytracker.db.session import SessionLocal
+from pyquerytracker.websocket import websocket_endpoint
+
+app = FastAPI(title="Query Tracker API")
+
+templates = Jinja2Templates(directory="templates")
+
+
+if get_config().dashboard_enabled:
+
+    @app.get("/dashboard", response_class=HTMLResponse)
+    def dashboard(request: Request):
+        return templates.TemplateResponse("dashboard.html", {"request": request})
+
+
+@app.get("/api/query-stats")
+def get_query_stats(minutes: int = Query(5, ge=1, le=1440)):
+    cutoff = datetime.utcnow() - timedelta(minutes=minutes)
+    print(f"[DEBUG] Cutoff: {cutoff}")
+
+    session = SessionLocal()
+    try:
+        logs = (
+            session.query(TrackedQuery)
+            .filter(TrackedQuery.timestamp >= cutoff)  # Now comparing text to text
+            .order_by(TrackedQuery.timestamp)
+            .all()
+        )
+        print(f"[DEBUG] Matching logs: {len(logs)}")
+        return {
+            "labels": [q.timestamp for q in logs],
+            "durations": [q.duration_ms for q in logs],
+            "events": [q.event for q in logs],
+            "function_names": [q.function_name for q in logs],
+        }
+    finally:
+        session.close()
+
+
+@app.get("/debug/queries")
+def debug_queries():
+    session = SessionLocal()
+    try:
+        rows = (
+            session.query(TrackedQuery)
+            .order_by(TrackedQuery.timestamp.desc())
+            .limit(5)
+            .all()
+        )
+        return [
+            {
+                "timestamp": r.timestamp,
+                "duration_ms": r.duration_ms,
+                "event": r.event,
+            }
+            for r in rows
+        ]
+    finally:
+        session.close()
+
+
+@app.websocket("/ws")
+async def websocket_route(websocket: WebSocket):
+    await websocket_endpoint(websocket)

pyquerytracker/config.py

@@ -1,7 +1,7 @@
-from enum import Enum
+import logging
 from dataclasses import dataclass
+from enum import Enum
 from typing import Optional
-import logging
 
 
 class ExportType(str, Enum):
@@ -23,15 +23,22 @@ class Config:
     Configuration settings for the query tracking system.
 
     Attributes:
-        slow_log_threshold_ms (float): Threshold in milliseconds above which a query is considered slow.
-                                        Defaults to 100.0 ms.
-        slow_log_level (int): Logging level for slow query logs (e.g., logging.WARNING, logging.INFO).
-                              Defaults to logging.WARNING.
+        slow_log_threshold_ms (float):
+            Threshold in milliseconds above which a query is considered slow.
+            Defaults to 100.0 ms.
+
+        slow_log_level (int):
+            Logging level for slow query logs (e.g., logging.WARNING, logging.INFO).
+            Defaults to logging.WARNING.
     """
 
     # TODO: Adding export functionality
     slow_log_threshold_ms: float = 100.0
     slow_log_level: int = logging.WARNING
+    export_type: Optional[ExportType] = None
+    export_path: Optional[str] = None
+    dashboard_enabled: bool = True  # ← set to False in real deployments
+    persist_to_db: bool = True
 
 
 _config: Config = Config()
@@ -40,20 +47,29 @@ _config: Config = Config()
 def configure(
     slow_log_threshold_ms: Optional[float] = None,
     slow_log_level: Optional[int] = None,
+    export_type: Optional[ExportType] = None,
+    export_path: Optional[str] = None,
 ):
     """
     Configure global settings for query tracking.
 
     Args:
-        slow_log_threshold_ms (Optional[float]): Threshold in milliseconds to log a query as "slow".
-                                                 If not provided, defaults to 100.0 ms.
-        slow_log_level (Optional[int]): Logging level for slow queries (e.g., logging.INFO, logging.WARNING).
-                                        If not provided, defaults to logging.WARNING.
+        slow_log_threshold_ms (Optional[float]):
+            Threshold in milliseconds to log a query as "slow".
+            If not provided, defaults to 100.0 ms.
+
+        slow_log_level (Optional[int]):
+            Logging level for slow queries (e.g., logging.INFO, logging.WARNING).
+            If not provided, defaults to logging.WARNING.
     """
     if slow_log_threshold_ms is not None:
         _config.slow_log_threshold_ms = slow_log_threshold_ms
     if slow_log_level is not None:
         _config.slow_log_level = slow_log_level
+    if export_type is not None:
+        _config.export_type = export_type
+    if export_path is not None:
+        _config.export_path = export_path
 
 
 def get_config() -> Config: