ignis-observability 0.2.0__py3-none-any.whl

ignis_observability/__init__.py

@@ -0,0 +1,34 @@
+"""
+ignis_observability — Non-Blocking AI Observability Hub for multi-model LLM applications.
+
+Quick start::
+
+    from ignis_observability import ObsHub, DBManager, settings
+
+    db = DBManager(settings.DATABASE_URL)
+    await db.init_db()
+    await db.seed_prices()
+
+    hub = ObsHub(langsmith_api_key=settings.LANGCHAIN_API_KEY, db_manager=db)
+
+    @hub.observe(name="my_llm_call")
+    async def call_llm(prompt: str):
+        ...
+"""
+
+from .config import settings
+from .database import DBManager, UnifiedTrace, ModelPrice
+from .engine import ObsHub
+from .trace_builder import TraceBuilder
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "ObsHub",
+    "DBManager",
+    "UnifiedTrace",
+    "ModelPrice",
+    "TraceBuilder",
+    "settings",
+    "__version__",
+]

ignis_observability/config.py

@@ -0,0 +1,99 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    #APPLICATION NAME
+    APPLICATION_NAME: str = "ignis"
+    USER_ID: str = ""
+    
+    # OpenAI Configuration
+    OPENAI_API_KEY: str = ""
+    # Other LLM providers (optional)
+    ANTHROPIC_API_KEY: str = ""
+    GEMINI_API_KEY: str = ""
+
+    # LangSmith Configuration
+    LANGCHAIN_API_KEY: str = ""
+    LANGCHAIN_ENDPOINT: str = "https://api.smith.langchain.com"
+    LANGCHAIN_PROJECT: str = "default"
+    LANGCHAIN_PROJECT_ID: str = ""
+    LANGCHAIN_TRACING_V2: bool = True
+
+    # Database Configuration
+    DATABASE_URL: str = "sqlite+aiosqlite:///./obs_hub.db"
+
+    # Sync Configuration
+    SYNC_INTERVAL: int = 60  # Sync every 60 seconds
+
+    # Logging
+    LOG_LEVEL: str = "info"
+
+    # ------------------------------------------------------------------
+    # Environment & Request Context
+    # ------------------------------------------------------------------
+    ENVIRONMENT: str = "development"  # development, staging, production
+    SERVICE_NAME: str = "llm-app"
+    SERVICE_VERSION: str = "1.0.0"
+    DEFAULT_USER_ID: str = ""  # Can be overridden per request
+    DEFAULT_SESSION_ID: str = ""  # Can be overridden per request
+
+    # ------------------------------------------------------------------
+    # Advanced Tracing Configuration (Optional)
+    # ------------------------------------------------------------------
+    # Master toggle for advanced tracing features
+    ADVANCED_TRACING_ENABLED: bool = True
+
+    # Individual feature toggles (only apply when ADVANCED_TRACING_ENABLED=True)
+    CAPTURE_REQUEST_ID: bool = True  # Unique trace ID per request
+    CAPTURE_USER_SESSION: bool = True  # User ID & Session ID tracking
+    CAPTURE_LLM_PARAMS: bool = True  # temperature, top_p, max_tokens, etc.
+    CAPTURE_STATUS_ERROR: bool = True  # Status & error information
+    CAPTURE_TAGS: bool = True  # Custom tags for organization
+    CAPTURE_ENVIRONMENT: bool = True  # Environment context
+
+    # ------------------------------------------------------------------
+    # Additional Observability Platform Configuration
+    # ------------------------------------------------------------------
+    # LangWatch
+    LANGWATCH_API_KEY: str = ""
+    LANGWATCH_PROJECT: str = ""
+    LANGWATCH_ENDPOINT: str = ""
+    LANGWATCH_ENABLED: bool = False
+
+    # LangFuse
+    LANGFUSE_API_KEY: str = ""
+    LANGFUSE_DATASET: str = ""
+    LANGFUSE_ENDPOINT: str = ""
+    LANGFUSE_ENABLED: bool = False
+
+    # Arize Cloud
+    ARIZE_API_KEY: str = ""
+    ARIZE_SPACE_KEY: str = ""
+    ARIZE_MODEL_NAME: str = ""
+    ARIZE_ENDPOINT: str = ""
+    ARIZE_COLLECTOR_ENDPOINT: str = "https://otlp.arize.com"
+    ARIZE_PROJECT: str = ""
+    ARIZE_ENABLED: bool = False
+
+    # Arize Phoenix (open-source observability)
+    PHOENIX_API_KEY: str = ""
+    PHOENIX_COLLECTOR_ENDPOINT: str = "https://app.phoenix.arize.com"
+
+    # Laminar
+    LAMINAR_API_KEY: str = ""
+    LAMINAR_PROJECT: str = ""
+    LAMINAR_ENDPOINT: str = ""
+    LAMINAR_ENABLED: bool = False
+
+    # OpenTelemetry (OTel)
+    OTEL_ENABLED: bool = False
+    OTEL_EXPORTER_OTLP_ENDPOINT: str = "http://localhost:4317"
+    OTEL_SERVICE_NAME: str = "llm-app"
+    OTEL_ENVIRONMENT: str = "development"
+
+    model_config = SettingsConfigDict(
+        env_file=".env", env_file_encoding="utf-8", case_sensitive=True, extra="ignore"
+    )
+
+
+settings = Settings()

ignis_observability/database.py

@@ -0,0 +1,135 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import JSON, DateTime, Float, Integer, String, func, select
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class Base(DeclarativeBase):
+    """Base class for all database models"""
+
+
+class ModelPrice(Base):
+    __tablename__ = "model_prices"
+    model: Mapped[str] = mapped_column(String, primary_key=True)
+    input_1k_price: Mapped[float] = mapped_column(Float)  # Price per 1k tokens
+    output_1k_price: Mapped[float] = mapped_column(Float)
+
+
+class UnifiedTrace(Base):
+    __tablename__ = "llm_traces"
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    timestamp: Mapped[datetime] = mapped_column(DateTime, default=func.now())
+    name: Mapped[str] = mapped_column(String)
+    model: Mapped[str] = mapped_column(String)
+    latency_ms: Mapped[float] = mapped_column(Float)
+    prompt_tokens: Mapped[int] = mapped_column(Integer, default=0)
+    completion_tokens: Mapped[int] = mapped_column(Integer, default=0)
+    total_cost: Mapped[float] = mapped_column(Float, default=0.0)
+    prompt: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    completion: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+
+    # Advanced tracing fields
+    request_id: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    session_id: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    user_id: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    status: Mapped[str] = mapped_column(
+        String, default="success"
+    )  # success, error, timeout
+    error: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    tags: Mapped[Optional[str]] = mapped_column(
+        String, nullable=True
+    )  # comma-separated
+    environment: Mapped[str] = mapped_column(String, default="development")
+    llm_params_json: Mapped[Optional[dict]] = mapped_column(
+        JSON, nullable=True
+    )  # temperature, max_tokens, etc.
+
+    metadata_json: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True)
+
+
+class DBManager:
+    def __init__(self, db_url: str = "sqlite+aiosqlite:///./obs_hub.db"):
+        self.engine = create_async_engine(db_url)
+        self.session_factory = async_sessionmaker(self.engine, expire_on_commit=False)
+
+    async def init_db(self):
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+    async def save_trace(self, data: dict):
+        """Save a trace, filtering to only database fields and converting types"""
+        async with self.session_factory() as session:
+            # Extract only fields that exist in UnifiedTrace model
+            db_fields = {
+                "id",
+                "timestamp",
+                "name",
+                "model",
+                "latency_ms",
+                "prompt_tokens",
+                "completion_tokens",
+                "total_cost",
+                "prompt",
+                "completion",
+                "request_id",
+                "session_id",
+                "user_id",
+                "status",
+                "error",
+                "tags",
+                "environment",
+                "llm_params_json",
+                "metadata_json",
+            }
+
+            filtered_data = {k: v for k, v in data.items() if k in db_fields}
+
+            # Convert tags list to comma-separated string if needed
+            if "tags" in filtered_data and isinstance(filtered_data["tags"], list):
+                filtered_data["tags"] = ",".join(filtered_data["tags"])
+
+            try:
+                # Create ORM object and add to session (don't await ORM methods)
+                trace = UnifiedTrace(**filtered_data)
+                session.add(trace)
+                await session.commit()
+            except Exception as e:
+                await session.rollback()
+                print(f"Error saving trace: {e}")
+
+    async def seed_prices(self):
+        async with self.session_factory() as session:
+            # 2026 Estimated Pricing (based on current trends)
+            prices = [
+                ModelPrice(
+                    model="gpt-3.5-turbo", input_1k_price=0.0005, output_1k_price=0.0015
+                ),
+                ModelPrice(
+                    model="gpt-4o", input_1k_price=0.0025, output_1k_price=0.010
+                ),
+                ModelPrice(
+                    model="gpt-4o-mini", input_1k_price=0.00015, output_1k_price=0.0006
+                ),
+            ]
+            for p in prices:
+                await session.merge(p)
+            await session.commit()
+
+    async def calculate_and_save(self, data: dict):
+        async with self.session_factory() as session:
+            # Fetch rates for the model
+            res = await session.execute(
+                select(ModelPrice).where(ModelPrice.model == data["model"])
+            )
+            price = res.scalar_one_or_none()
+
+            if price:
+                input_cost = (data["prompt_tokens"] / 1000) * price.input_1k_price
+                output_cost = (data["completion_tokens"] / 1000) * price.output_1k_price
+                data["total_cost"] = input_cost + output_cost
+
+            await session.merge(UnifiedTrace(**data))
+            await session.commit()