tracing with phoenix

README.md

@@ -13,4 +13,47 @@ hf_oauth: true
 hf_oauth_expiration_minutes: 480
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SmolaAgents Course Final Assignment
+
+This application is a demonstration of creating a robust agent system with monitoring and tracing capabilities.
+
+## Features
+
+- **Multi-Agent System**: Uses a manager agent to orchestrate a specialized web agent.
+- **Advanced Models**: Leverages Qwen and DeepSeek models through HuggingFace's Inference API.
+- **Gradio Interface**: Simple UI for agent interaction and evaluation.
+- **Comprehensive Tracing**: Integrated observability through Langfuse and Phoenix.
+
+## Tracing and Monitoring
+
+The application includes a modular tracing system that supports both:
+
+### Langfuse
+- Cloud-based LLM observability platform
+- Configure with environment variables:
+  - `LANGFUSE_PUBLIC_KEY`
+  - `LANGFUSE_SECRET_KEY`
+  - `LANGFUSE_HOST` (defaults to EU region)
+
+### Arize Phoenix
+- Local, open-source LLM observability tool
+- Start the Phoenix UI with:
+  ```
+  python -m phoenix.server.main serve
+  ```
+- View traces at http://localhost:6006
+
+You can enable either or both systems by configuring the tracing setup:
+
+```python
+# Use just Langfuse
+initialize_tracing(provider="langfuse")
+
+# Use just Phoenix
+initialize_tracing(provider="phoenix")
+
+# Use both (default)
+initialize_tracing(provider="both")
+```
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent.py

@@ -6,11 +6,36 @@ from smolagents import (
     InferenceClientModel,
 )
 from dotenv import load_dotenv
+from tracing import setup_tracing
 
 load_dotenv()
 
+# Initialize tracing when module is imported
+trace_provider = None
+
+
+def initialize_tracing(enabled=True, provider="both"):
+    """
+    Initialize tracing for the agent module
+
+    Args:
+        enabled: Whether tracing should be active
+        provider: Which provider(s) to use - "langfuse", "phoenix", or "both"
+    """
+    global trace_provider
+    if trace_provider is None:
+        trace_provider = setup_tracing(
+            service_name="smolagent", enabled=enabled, provider=provider
+        )
+    return trace_provider
+
 
 def get_agent():
+    # Ensure tracing is initialized
+    initialize_tracing()
+
+    # SmolagentsInstrumentor will automatically trace agent operations
+
     llm_qwen = InferenceClientModel(
         model_id="Qwen/Qwen2.5-Coder-32B-Instruct", provider="together"
     )
@@ -18,6 +43,7 @@ def get_agent():
         "deepseek-ai/DeepSeek-R1", provider="together", max_tokens=8096
     )
 
+    # Create web agent
     web_agent = ToolCallingAgent(
         tools=[DuckDuckGoSearchTool(), VisitWebpageTool()],
         model=llm_qwen,
@@ -26,6 +52,7 @@ def get_agent():
         description="A web agent that can search the web and visit webpages.",
     )
 
+    # Create manager agent
     manager_agent = CodeAgent(
         tools=[],
         managed_agents=[web_agent],
@@ -36,7 +63,19 @@ def get_agent():
 
 
 if __name__ == "__main__":
+    # Initialize tracing when run directly - enable both Langfuse and Phoenix
+    initialize_tracing(enabled=True, provider="both")
+
+    # Get agent with tracing already configured
     agent = get_agent()
-    agent.run(
+
+    # Run agent - SmolagentsInstrumentor will automatically trace the execution
+    print("Running agent with tracing enabled...")
+    result = agent.run(
         "What is the latest news about AI? Please search the web and summarize the results."
     )
+    print(f"Result: {result}")
+    print(
+        "View traces in Phoenix UI (run 'python -m phoenix.server.main serve' in another terminal)"
+    )
+    print("View traces in Langfuse dashboard (if configured)")

app.py

@@ -3,13 +3,7 @@ import gradio as gr
 import requests
 import pandas as pd
 from dotenv import load_dotenv
-import base64
-from opentelemetry.sdk.trace import TracerProvider
-from openinference.instrumentation.smolagents import SmolagentsInstrumentor
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from opentelemetry import trace
-from .agent import get_agent
+from agent import get_agent, initialize_tracing
 
 load_dotenv()
 
@@ -17,35 +11,8 @@ load_dotenv()
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-
-# Get your own keys from https://cloud.langfuse.com
-
-
-os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com"  # 🇪🇺 EU region example
-# os.environ["LANGFUSE_HOST"] = "https://us.cloud.langfuse.com"  # 🇺🇸 US region example
-
-LANGFUSE_AUTH = base64.b64encode(
-    f"{os.environ.get('LANGFUSE_PUBLIC_KEY')}:{os.environ.get('LANGFUSE_SECRET_KEY')}".encode()
-).decode()
-
-os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = (
-    os.environ.get("LANGFUSE_HOST") + "/api/public/otel"
-)
-os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"Authorization=Basic {LANGFUSE_AUTH}"
-
-# Create a TracerProvider for OpenTelemetry
-trace_provider = TracerProvider()
-
-# Add a SimpleSpanProcessor with the OTLPSpanExporter to send traces
-trace_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
-
-# Set the global default tracer provider
-
-trace.set_tracer_provider(trace_provider)
-tracer = trace.get_tracer(__name__)
-
-# Instrument smolagents with the configured provider
-SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
+# Initialize tracing - smolagents instrumentation will handle the rest
+trace_provider = initialize_tracing(service_name="smolagent-app")
 
 
 # --- Basic Agent Definition ---

tracing.py

@@ -0,0 +1,94 @@
+import os
+import base64
+from typing import Optional, Literal
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry import trace
+from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+
+
+def setup_tracing(
+    service_name: str = "agent-service",
+    enabled: bool = True,
+    provider: Literal["langfuse", "phoenix", "both"] = "langfuse",
+) -> Optional[TracerProvider]:
+    """
+    Configure and set up OpenTelemetry tracing with Langfuse and/or Phoenix integration.
+
+    Args:
+        service_name: Name of the service for trace identification
+        enabled: Whether tracing should be active
+        provider: Which tracing provider(s) to use - "langfuse", "phoenix", or "both"
+
+    Returns:
+        Configured TracerProvider instance or None if disabled
+    """
+    if not enabled:
+        return None
+
+    trace_provider = None
+
+    # Setup Phoenix if requested
+    if provider in ["phoenix", "both"]:
+        try:
+            from phoenix.otel import register
+
+            # Create Phoenix tracer provider
+
+            trace_provider = register(
+                project_name=service_name,
+                endpoint="http://127.0.0.1:6006/v1/traces",
+                auto_instrument=True,
+            )
+            print(f"✅ Phoenix tracing enabled for {service_name}")
+
+        except ImportError:
+            print("⚠️ Phoenix not installed. Run: pip install 'smolagents[telemetry]'")
+
+    # Setup Langfuse if requested
+    if provider in ["langfuse", "both"]:
+        # Configure Langfuse host
+        langfuse_host = os.environ.get("LANGFUSE_HOST", "https://cloud.langfuse.com")
+
+        # Create auth token for Langfuse
+        langfuse_public_key = os.environ.get("LANGFUSE_PUBLIC_KEY")
+        langfuse_secret_key = os.environ.get("LANGFUSE_SECRET_KEY")
+
+        if not langfuse_public_key or not langfuse_secret_key:
+            print("⚠️ Langfuse keys not found in environment")
+
+            # If Phoenix is not set up either, return None
+            if trace_provider is None:
+                return None
+        else:
+            langfuse_auth = base64.b64encode(
+                f"{langfuse_public_key}:{langfuse_secret_key}".encode()
+            ).decode()
+
+            # Set environment variables for OTLP exporter
+            os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = (
+                f"{langfuse_host}/api/public/otel"
+            )
+            os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = (
+                f"Authorization=Basic {langfuse_auth}"
+            )
+
+            if trace_provider is None:
+                # Create new TracerProvider if Phoenix wasn't enabled
+                trace_provider = TracerProvider()
+                # Set as the global default tracer provider
+                trace.set_tracer_provider(trace_provider)
+
+            # Add Langfuse exporter to the tracer provider
+            trace_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
+            print(f"✅ Langfuse tracing enabled for {service_name}")
+
+    if trace_provider:
+        # Instrument smolagents with the configured provider
+        SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
+
+        # Create a single tracer for the entire application
+        trace.get_tracer(service_name)
+
+    return trace_provider