Upload folder using huggingface_hub

pyproject.toml

@@ -159,7 +159,7 @@ dependencies = [
     "google-auth-oauthlib>=0.4.6",
     "google-auth-httplib2>=0.1.0",
     "autoflake>=1.5.0",
-
+    "psycopg2-binary>=2.9.9",
 ]
 
 [dependency-groups]

src/core/mcp_telemetry.py

@@ -10,8 +10,9 @@ from pathlib import Path
 # Configuration
 HUB_URL = os.environ.get("MCP_HUB_URL", "http://localhost:7860")
 IS_HUB = os.environ.get("MCP_IS_HUB", "false").lower() == "true"
+PG_CONN_STR = os.environ.get("MCP_TRACES_DB")
 
-# Single SQLite DB for the Hub
+# Single SQLite DB for the Hub (fallback)
 if os.path.exists("/app"):
     DB_FILE = Path("/tmp/mcp_logs.db")
 else:
@@ -19,6 +20,22 @@ else:
     DB_FILE = Path(__file__).parent.parent.parent / "mcp_logs.db"
 
 def _get_conn():
+    # PostgreSQL Mode
+    if PG_CONN_STR and IS_HUB:
+        try:
+            import psycopg2
+            from psycopg2.extras import RealDictCursor
+            conn = psycopg2.connect(PG_CONN_STR)
+            # Init schema if needed (lazy check could be optimized)
+            _init_pg_db(conn)
+            return conn
+        except Exception as e:
+            print(f"Postgres Connection Failed: {e}")
+            # Fallback to SQLite not recommended if PG configured, but handling graceful failure might be needed.
+            # For now, we raise or assume SQLite fallback if PG fail? Let's error out to be safe.
+            raise e
+
+    # SQLite Mode (Default)
     # Auto-init if missing (lazy creation)
     if IS_HUB and not os.path.exists(DB_FILE):
         _init_db()
@@ -27,6 +44,57 @@ def _get_conn():
     conn.row_factory = sqlite3.Row
     return conn
 
+
+def _init_pg_db(conn):
+    """Initializes the PostgreSQL database with required tables."""
+    try:
+        with conn.cursor() as cur:
+            # Logs
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS logs (
+                    id SERIAL PRIMARY KEY,
+                    timestamp TIMESTAMP NOT NULL DEFAULT NOW(),
+                    server VARCHAR(255) NOT NULL,
+                    tool VARCHAR(255) NOT NULL
+                )
+            """)
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs(timestamp)")
+            
+            # Traces
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS traces (
+                    id SERIAL PRIMARY KEY,
+                    trace_id VARCHAR(64) NOT NULL,
+                    span_id VARCHAR(64) NOT NULL,
+                    parent_id VARCHAR(64),
+                    name VARCHAR(255) NOT NULL,
+                    status VARCHAR(50),
+                    start_time TIMESTAMP,
+                    end_time TIMESTAMP,
+                    duration_ms FLOAT,
+                    server VARCHAR(255)
+                )
+            """)
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_traces_tid ON traces(trace_id)")
+            
+            # Metrics
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS metrics (
+                    id SERIAL PRIMARY KEY,
+                    name VARCHAR(255) NOT NULL,
+                    value FLOAT NOT NULL,
+                    tags TEXT,
+                    timestamp TIMESTAMP NOT NULL DEFAULT NOW(),
+                    server VARCHAR(255)
+                )
+            """)
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_metrics_ts ON metrics(timestamp)")
+            
+        conn.commit()
+    except Exception as e:
+        print(f"Postgres DB Init Failed: {e}")
+        conn.rollback()
+
 def _init_db():
     """Initializes the SQLite database with required tables."""
     # Ensure parent dir exists
@@ -46,7 +114,34 @@ def _init_db():
                     tool TEXT NOT NULL
                 )
             """)
-            conn.execute("CREATE INDEX IF NOT EXISTS idx_ts ON logs(timestamp)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs(timestamp)")
+            
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS traces (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    trace_id TEXT NOT NULL,
+                    span_id TEXT NOT NULL,
+                    parent_id TEXT,
+                    name TEXT NOT NULL,
+                    status TEXT,
+                    start_time TEXT,
+                    end_time TEXT,
+                    duration_ms REAL,
+                    server TEXT
+                )
+            """)
+            
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS metrics (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    value REAL NOT NULL,
+                    tags TEXT,
+                    timestamp TEXT NOT NULL,
+                    server TEXT
+                )
+            """)
+            
         conn.close()
     except Exception as e:
         print(f"DB Init Failed: {e}")
@@ -56,45 +151,111 @@ def _init_db():
 def log_usage(server_name: str, tool_name: str):
     """Logs a usage event. Writes to DB if Hub, else POSTs to Hub API."""
     timestamp = datetime.now().isoformat()
+    if IS_HUB:
+        _write_db("logs", {"timestamp": timestamp, "server": server_name, "tool": tool_name})
+    else:
+        _send_remote("log", {"timestamp": timestamp, "server": server_name, "tool": tool_name})
+
+def log_trace(server_name: str, trace_id: str, span_id: str, name: str, duration_ms: float, 
+              status: str = "ok", parent_id: str = None):
+    """Logs a trace span."""
+    now = datetime.now()
+    end_time = now.isoformat()
+    start_time = (now - timedelta(milliseconds=duration_ms)).isoformat()
+    
+    data = {
+        "server": server_name,
+        "trace_id": trace_id,
+        "span_id": span_id,
+        "parent_id": parent_id,
+        "name": name,
+        "status": status,
+        "start_time": start_time,
+        "end_time": end_time,
+        "duration_ms": duration_ms
+    }
+    
+    if IS_HUB:
+        _write_db("traces", data)
+    else:
+        _send_remote("trace", data)
+
+def log_metric(server_name: str, name: str, value: float, tags: dict = None):
+    """Logs a metric point."""
+    timestamp = datetime.now().isoformat()
+    tags_str = json.dumps(tags) if tags else "{}"
+    
+    data = {
+        "server": server_name,
+        "name": name,
+        "value": value,
+        "tags": tags_str,
+        "timestamp": timestamp
+    }
     
-    # 1. If we are the Hub, write directly to DB
     if IS_HUB:
-        try:
-            with _get_conn() as conn:
-                conn.execute("INSERT INTO logs (timestamp, server, tool) VALUES (?, ?, ?)", 
-                             (timestamp, server_name, tool_name))
-        except Exception as e:
-            print(f"Local Log Failed: {e}")
-            
-    # 2. If we are an Agent, send to Hub API
+        _write_db("metrics", data)
     else:
-        try:
-            payload = {
-                "server": server_name,
-                "tool": tool_name,
-                "timestamp": timestamp
-            }
-            # Fire and forget with short timeout
-            requests.post(f"{HUB_URL}/api/telemetry", json=payload, timeout=2)
-        except Exception as e:
-            # excessive logging here would be spammy locally
-            pass
+        _send_remote("metric", data)
+
+def _write_db(table: str, data: dict):
+    """Helper to write to DB (PG or SQLite)."""
+    try:
+        conn = _get_conn()
+        cols = list(data.keys())
+        placeholders = ["%s"] * len(cols) if PG_CONN_STR and IS_HUB else ["?"] * len(cols)
+        query = f"INSERT INTO {table} ({', '.join(cols)}) VALUES ({', '.join(placeholders)})"
+        values = list(data.values())
+        
+        if PG_CONN_STR and IS_HUB:
+            with conn.cursor() as cur:
+                cur.execute(query, values)
+            conn.commit()
+            conn.close()
+        else:
+            with conn:
+                conn.execute(query, values)
+            conn.close()
+    except Exception as e:
+        print(f"Local Write Failed ({table}): {e}")
+
+def _send_remote(type: str, data: dict):
+    """Helper to post to Hub."""
+    try:
+        # Fire and forget
+        requests.post(f"{HUB_URL}/api/telemetry/{type}", json=data, timeout=2)
+    except Exception:
+        pass
 
 def get_metrics():
-    """Aggregates metrics from SQLite."""
-    if not DB_FILE.exists():
+    """Aggregates metrics from DB."""
+    if not IS_HUB and not DB_FILE.exists():
+         # If not Hub and no local sqlite, nothing to show
         return {}
     
     try:
-        with _get_conn() as conn:
+        conn = _get_conn()
+        metrics = {}
+        rows = []
+        
+        if PG_CONN_STR and IS_HUB:
+            from psycopg2.extras import RealDictCursor
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute("SELECT server, timestamp FROM logs")
+                rows = cur.fetchall()
+            conn.close()
+        else:
             rows = conn.execute("SELECT server, timestamp FROM logs").fetchall()
+            conn.close()
             
         now = datetime.now()
-        metrics = {}
         
         for row in rows:
             server = row["server"]
-            ts = datetime.fromisoformat(row["timestamp"])
+            # Handle different timestamp formats (PG vs SQLite textual)
+            ts = row["timestamp"]
+            if isinstance(ts, str):
+                ts = datetime.fromisoformat(ts)
             
             if server not in metrics:
                 metrics[server] = {"hourly": 0, "weekly": 0, "monthly": 0}
@@ -104,6 +265,7 @@ def get_metrics():
                 metrics[server]["hourly"] += 1
             if delta.days < 7:
                 metrics[server]["weekly"] += 1
+            if delta.days < 30: # Assuming a month is roughly 30 days for simplicity
                 metrics[server]["monthly"] += 1
                 
         return metrics
@@ -113,7 +275,7 @@ def get_metrics():
 
 def get_usage_history(range_hours: int = 24, intervals: int = 12):
     """Returns time-series data for the chart."""
-    if not DB_FILE.exists():
+    if not IS_HUB and not DB_FILE.exists():
         return _generate_mock_history(range_hours, intervals)
         
     try:
@@ -121,11 +283,21 @@ def get_usage_history(range_hours: int = 24, intervals: int = 12):
         start_time = now - timedelta(hours=range_hours)
         bucket_size = (range_hours * 3600) / intervals
         
-        with _get_conn() as conn:
+        conn = _get_conn()
+        rows = []
+        
+        if PG_CONN_STR and IS_HUB:
+            from psycopg2.extras import RealDictCursor
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute("SELECT server, timestamp FROM logs WHERE timestamp >= %s", (start_time,))
+                rows = cur.fetchall()
+            conn.close()
+        else:
             rows = conn.execute(
                 "SELECT server, timestamp FROM logs WHERE timestamp >= ?", 
                 (start_time.isoformat(),)
             ).fetchall()
+            conn.close()
 
         if not rows:
             return _generate_mock_history(range_hours, intervals)
@@ -135,7 +307,10 @@ def get_usage_history(range_hours: int = 24, intervals: int = 12):
         datasets = {s: [0] * intervals for s in active_servers}
         
         for row in rows:
-            ts = datetime.fromisoformat(row["timestamp"])
+            ts = row["timestamp"]
+            if isinstance(ts, str):
+                ts = datetime.fromisoformat(ts)
+                
             delta = (ts - start_time).total_seconds()
             bucket_idx = int(delta // bucket_size)
             if 0 <= bucket_idx < intervals:
@@ -210,16 +385,28 @@ def get_system_metrics():
 
 def get_recent_logs(server_id: str, limit: int = 50):
     """Fetches the most recent logs for a specific server."""
-    if not DB_FILE.exists():
+    if not IS_HUB and not DB_FILE.exists():
         return []
         
     try:
-        with _get_conn() as conn:
-            # Simple match. For 'mcp-hub', we might want all, but usually filtered by server_id
+        conn = _get_conn()
+        rows = []
+        
+        if PG_CONN_STR and IS_HUB:
+            from psycopg2.extras import RealDictCursor
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                 cur.execute(
+                    "SELECT timestamp, tool FROM logs WHERE server = %s ORDER BY id DESC LIMIT %s", 
+                    (server_id, limit)
+                )
+                 rows = cur.fetchall()
+            conn.close()
+        else:
             rows = conn.execute(
                 "SELECT timestamp, tool FROM logs WHERE server = ? ORDER BY id DESC LIMIT ?", 
                 (server_id, limit)
             ).fetchall()
+            conn.close()
             
         return [dict(r) for r in rows]
     except Exception as e:

src/mcp-azure-sre/server.py

@@ -14,7 +14,9 @@ if src_dir not in sys.path:
     sys.path.append(src_dir)
 
 from mcp.server.fastmcp import FastMCP
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
 
 # Azure Imports
 try:
@@ -45,7 +47,11 @@ def list_resources(subscription_id: str, resource_group: Optional[str] = None) -
     """
     List Azure resources in a subscription or resource group.
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
     log_usage("mcp-azure-sre", "list_resources")
+    
     try:
         cred = get_credential()
         client = ResourceManagementClient(cred, subscription_id)
@@ -55,8 +61,15 @@ def list_resources(subscription_id: str, resource_group: Optional[str] = None) -
         else:
             resources = client.resources.list()
             
-        return [{"name": r.name, "type": r.type, "location": r.location, "id": r.id} for r in resources]
+        results = [{"name": r.name, "type": r.type, "location": r.location, "id": r.id} for r in resources]
+        
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-azure-sre", trace_id, span_id, "list_resources", duration, "ok")
+        log_metric("mcp-azure-sre", "resources_scanned", len(results), {"sub": subscription_id})
+        return results
     except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-azure-sre", trace_id, span_id, "list_resources", duration, "error")
         return [{"error": str(e)}]
 
 @mcp.tool()

src/mcp-github/server.py

@@ -6,7 +6,10 @@ import sys
 import os
 from mcp.server.fastmcp import FastMCP
 from typing import List, Dict, Any, Optional
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
+import datetime
 
 # Add src to pythonpath
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -39,7 +42,11 @@ def list_repositories() -> List[Dict[str, Any]]:
     """
     List all repositories for the authenticated user/owner.
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
     log_usage("mcp-github", "list_repositories")
+    
     try:
         g = get_client()
         # Get repos for the owner/authenticated user
@@ -56,8 +63,15 @@ def list_repositories() -> List[Dict[str, Any]]:
                 "updated_at": str(repo.updated_at),
                 "language": repo.language
             })
+        
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-github", trace_id, span_id, "list_repositories", duration, "ok")
+        log_metric("mcp-github", "repos_fetched", len(results), {"status": "ok"})
         return results
+        
     except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-github", trace_id, span_id, "list_repositories", duration, "error")
         return [{"error": str(e)}]
 
 @mcp.tool()

src/mcp-hub/api.py

@@ -13,52 +13,82 @@ from datetime import datetime, timedelta
 # Add parent dir to path for imports
 sys.path.append(str(Path(__file__).parent.parent))
 
+# Core Telemetry Imports for Metrics/History
+from core.mcp_telemetry import get_metrics, get_usage_history, get_system_metrics, get_recent_logs
+
+
 # Telemetry Import
 try:
-    from core.mcp_telemetry import get_metrics, get_usage_history, get_system_metrics, log_usage, _get_conn, get_recent_logs
+    from core.mcp_telemetry import _write_db
 except ImportError:
     # If standard import fails, try absolute path fallback
     sys.path.append(str(Path(__file__).parent.parent.parent))
-    from src.core.mcp_telemetry import get_metrics, get_usage_history, get_system_metrics, log_usage, _get_conn, get_recent_logs
-
-# Optional: HF Hub for status checks
-try:
-    from huggingface_hub import HfApi
-    hf_api = HfApi()
-except ImportError:
-    hf_api = None
+    from src.core.mcp_telemetry import _write_db
 
 from pydantic import BaseModel
 
-class TelemetryEvent(BaseModel):
+class LogEvent(BaseModel):
     server: str
     tool: str
     timestamp: Optional[str] = None
 
+class TraceEvent(BaseModel):
+    server: str
+    trace_id: str
+    span_id: str
+    name: str
+    duration_ms: float
+    status: Optional[str] = "ok"
+    parent_id: Optional[str] = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+
+class MetricEvent(BaseModel):
+    server: str
+    name: str
+    value: float
+    tags: Optional[str] = "{}"
+    timestamp: Optional[str] = None
+
 app = FastAPI()
 
 @app.post("/api/telemetry")
-async def ingest_telemetry(event: TelemetryEvent):
-    """Ingests telemetry from remote MCP agents."""
-    # We use the internal log_usage which handles DB writing
-    # We must ensure we are in Hub mode for this to work, which we are since this is api.py
-    # But wait, log_usage checks IS_HUB env var.
-    # To be safe, we will write directly or ensure env var is set in Dockerfile.
-    
-    # Actually, simpler: we can just call the DB insert directly here to retrieve avoiding circular logic
-    # or just use log_usage if configured correctly.
-    
-    # Let's import the specific DB function or use sqlite directly
-    from core.mcp_telemetry import _get_conn
-    
+@app.post("/api/telemetry/log")
+async def ingest_log(event: LogEvent):
+    """Ingests usage logs."""
+    try:
+        ts = event.timestamp or datetime.now().isoformat()
+        _write_db("logs", {
+            "timestamp": ts,
+            "server": event.server,
+            "tool": event.tool
+        })
+        return {"status": "ok"}
+    except Exception as e:
+        print(f"Log Ingest Failed: {e}")
+        return {"status": "error", "message": str(e)}
+
+@app.post("/api/telemetry/trace")
+async def ingest_trace(event: TraceEvent):
+    """Ingests distributed traces."""
+    try:
+        _write_db("traces", event.dict())
+        return {"status": "ok"}
+    except Exception as e:
+        print(f"Trace Ingest Failed: {e}")
+        return {"status": "error", "message": str(e)}
+
+@app.post("/api/telemetry/metric")
+async def ingest_metric(event: MetricEvent):
+    """Ingests quantitative metrics."""
     try:
         ts = event.timestamp or datetime.now().isoformat()
-        with _get_conn() as conn:
-             conn.execute("INSERT INTO logs (timestamp, server, tool) VALUES (?, ?, ?)", 
-                          (ts, event.server, event.tool))
+        data = event.dict()
+        data["timestamp"] = ts
+        _write_db("metrics", data)
         return {"status": "ok"}
     except Exception as e:
-        print(f"Telemetry Ingest Failed: {e}")
+        print(f"Metric Ingest Failed: {e}")
         return {"status": "error", "message": str(e)}
 
 app.add_middleware(
@@ -166,11 +196,32 @@ print(result.final_text)
 
 @app.on_event("startup")
 async def startup_event():
+    # 1. Environment Check
     token = os.environ.get("HF_TOKEN")
+    is_hub = os.environ.get("MCP_IS_HUB", "false")
+    pg_db = os.environ.get("MCP_TRACES_DB")
+    
+    print("--- MCP HUB BOOT SEQUENCE ---")
+    print(f"ENV MCP_IS_HUB: {is_hub}")
+    
     if token:
-        print(f"HF_TOKEN found: {token[:4]}...{token[-4:]}")
+        print(f"ENV HF_TOKEN: Configured ({len(token)} chars)")
     else:
         print("WARNING: HF_TOKEN not set! Live status checks will fail.")
+        
+    # 2. Database Check
+    if pg_db:
+        print(f"ENV MCP_TRACES_DB: Configured (Scheme: {pg_db.split(':')[0]})")
+        try:
+            import psycopg2
+            print("DEPENDENCY: psycopg2-binary installed.")
+            # We don't connect here to avoid blocking start, but telemetry module will try.
+        except ImportError:
+            print("CRITICAL ERROR: psycopg2-binary NOT installed. Postgres will fail!")
+    else:
+        print("ENV MCP_TRACES_DB: Not set. Using SQLite fallback.")
+        
+    print("--- SEQUENCE COMPLETE ---")
 
 @app.get("/api/servers/{server_id}/logs")
 async def get_server_logs(server_id: str):

src/mcp-hub/src/App.vue

@@ -161,7 +161,7 @@ const system = ref({ uptime: '99.9%', throughput: '0/hr', latency: '0ms' })
 const usageData = ref({ labels: [], datasets: [] })
 const selectedServer = ref(null)
 const currentLogs = ref('Initializing terminal...')
-const selectedRange = ref('24h')
+const selectedRange = ref('1h')
 const ranges = ['1h', '24h', '7d', '30d']
 const hoverInfo = ref(null)
 let logTimer = null
@@ -327,7 +327,7 @@ onMounted(() => {
   setInterval(() => {
     fetchData()
     fetchUsage()
-  }, 15000)
+  }, 300000)
 })
 </script>
 

src/mcp-rag-secure/server.py

@@ -10,7 +10,8 @@ from chromadb.config import Settings
 from chromadb.utils import embedding_functions
 from mcp.server.fastmcp import FastMCP
 from typing import List, Dict, Any, Optional
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import time
 
 # Initialize FastMCP Server
 mcp = FastMCP("Secure RAG", host="0.0.0.0")
@@ -69,24 +70,35 @@ def query_knowledge_base(tenant_id: str, query: str, k: int = 3) -> List[Dict[st
     """
     Query the knowledge base. Results are strictly filtered by tenant_id.
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
     log_usage("mcp-rag-secure", "query_knowledge_base")
-    results = collection.query(
-        query_texts=[query],
-        n_results=k,
-        where={"tenant_id": tenant_id} # Critical security filter
-    )
     
-    formatted_results = []
-    if results["documents"]:
-        for i, doc in enumerate(results["documents"][0]):
-            meta = results["metadatas"][0][i]
-            formatted_results.append({
-                "content": doc,
-                "metadata": meta,
-                "score": results["distances"][0][i] if results["distances"] else None
-            })
-            
-    return formatted_results
+    try:
+        results = collection.query(
+            query_texts=[query],
+            n_results=k,
+            where={"tenant_id": tenant_id} # Critical security filter
+        )
+        
+        formatted_results = []
+        if results["documents"]:
+            for i, doc in enumerate(results["documents"][0]):
+                meta = results["metadatas"][0][i]
+                formatted_results.append({
+                    "content": doc,
+                    "metadata": meta,
+                    "score": results["distances"][0][i] if results["distances"] else None
+                })
+        
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-rag-secure", trace_id, span_id, "query_knowledge_base", duration, "ok")
+        return formatted_results
+    except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-rag-secure", trace_id, span_id, "query_knowledge_base", duration, "error")
+        raise e
 
 @mcp.tool()
 def delete_tenant_data(tenant_id: str) -> str:

src/mcp-seo/server.py

@@ -9,7 +9,9 @@ from bs4 import BeautifulSoup
 from urllib.parse import urljoin, urlparse
 from mcp.server.fastmcp import FastMCP
 from typing import List, Dict, Any, Set
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
 
 # Initialize FastMCP Server
 mcp = FastMCP("SEO & ADA Audit", host="0.0.0.0")
@@ -20,7 +22,11 @@ def analyze_seo(url: str) -> Dict[str, Any]:
     Perform a basic SEO audit of a webpage.
     Checks title, meta description, H1 tags, image alt attributes, and internal/external links.
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
     log_usage("mcp-seo", "analyze_seo")
+    
     try:
         response = requests.get(url, timeout=10)
         soup = BeautifulSoup(response.content, 'html.parser')
@@ -57,9 +63,15 @@ def analyze_seo(url: str) -> Dict[str, Any]:
             else:
                 result["external_links"] += 1
                 
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-seo", trace_id, span_id, "analyze_seo", duration, "ok")
+        log_metric("mcp-seo", "seo_links_found", result["internal_links"] + result["external_links"], {"url": url})
+        
         return result
     except Exception as e:
-        return {"error": str(e)}
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-seo", trace_id, span_id, "analyze_seo", duration, "error")
+        return [{"error": str(e)}]
 
 @mcp.tool()
 def analyze_ada(url: str) -> Dict[str, Any]:

src/mcp-trader/server.py

@@ -13,7 +13,9 @@ if src_dir not in sys.path:
 
 from mcp.server.fastmcp import FastMCP
 from typing import List, Dict, Any
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
 
 # Local imports (assuming src/mcp-trader is a package or run from src)
 try:
@@ -45,8 +47,25 @@ mcp = FastMCP("MCP Trader", host="0.0.0.0")
 @mcp.tool()
 def get_stock_price(symbol: str) -> float:
     """Get the current price for a stock symbol."""
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
+    
     log_usage("mcp-trader", "get_stock_price")
-    return get_current_price(symbol)
+    
+    try:
+        price = get_current_price(symbol)
+        duration = (time.time() - start_time) * 1000
+        
+        # Metric
+        log_metric("mcp-trader", "stock_price", price, {"symbol": symbol})
+        log_trace("mcp-trader", trace_id, span_id, "get_stock_price", duration, "ok")
+        
+        return price
+    except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-trader", trace_id, span_id, "get_stock_price", duration, "error")
+        raise e
 
 @mcp.tool()
 def get_stock_fundamentals(symbol: str) -> Dict[str, Any]:

src/mcp-trading-research/server.py

@@ -8,7 +8,9 @@ import yfinance as yf
 from textblob import TextBlob
 from mcp.server.fastmcp import FastMCP
 from typing import List, Dict, Any
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
 
 # Initialize FastMCP Server
 mcp = FastMCP("Trading Research", host="0.0.0.0")
@@ -18,7 +20,11 @@ def get_news_sentiment(symbol: str) -> List[Dict[str, Any]]:
     """
     Get recent news and analyze sentiment for a stock symbol.
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
     log_usage("mcp-trading-research", "get_news_sentiment")
+    
     try:
         ticker = yf.Ticker(symbol)
         news = ticker.news
@@ -46,8 +52,13 @@ def get_news_sentiment(symbol: str) -> List[Dict[str, Any]]:
                 "sentiment_score": round(sentiment, 2),
                 "sentiment_label": sentiment_label
             })
+        
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-trading-research", trace_id, span_id, "get_news_sentiment", duration, "ok")
         return results
     except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-trading-research", trace_id, span_id, "get_news_sentiment", duration, "error")
         return [{"error": str(e)}]
 
 @mcp.tool()

src/mcp-weather/server.py

@@ -11,7 +11,10 @@ if src_dir not in sys.path:
     sys.path.append(src_dir)
 
 from mcp.server.fastmcp import FastMCP
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
+from datetime import datetime
 
 # Initialize FastMCP Server
 mcp = FastMCP("Weather MCP", host="0.0.0.0")
@@ -30,25 +33,47 @@ def get_current_weather(location: str, units: str = "metric") -> Dict[str, Any]:
     Get current weather for a specific city or location.
     Units can be 'metric' (Celsius) or 'imperial' (Fahrenheit).
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
+    
     log_usage("mcp-weather", "get_current_weather")
     if not OPENWEATHER_API_KEY:
+        log_trace("mcp-weather", trace_id, span_id, "get_current_weather", 0, "error")
         return {"error": "OPENWEATHER_API_KEY not set"}
     
     url = f"https://api.openweathermap.org/data/2.5/weather?q={location}&appid={OPENWEATHER_API_KEY}&units={units}"
-    response = requests.get(url)
-    if response.status_code != 200:
-        return {"error": f"Failed to fetch weather: {response.text}"}
-    
-    data = response.json()
-    return {
-        "location": data.get("name"),
-        "condition": data["weather"][0]["description"],
-        "temperature": format_temp(data["main"]["temp"], units),
-        "feels_like": format_temp(data["main"]["feels_like"], units),
-        "humidity": f"{data['main']['humidity']}%",
-        "wind_speed": f"{data['wind']['speed']} m/s",
-        "timestamp": data.get("dt")
-    }
+    try:
+        response = requests.get(url, timeout=10)
+        duration = (time.time() - start_time) * 1000
+        
+        if response.status_code != 200:
+            log_trace("mcp-weather", trace_id, span_id, "get_current_weather", duration, "error")
+            return {"error": f"Failed to fetch weather: {response.text}"}
+        
+        data = response.json()
+        temp = data["main"]["temp"]
+        
+        # Log Metrics
+        log_metric("mcp-weather", "weather_temperature", temp, {"location": location, "unit": units})
+        log_metric("mcp-weather", "api_latency", duration, {"endpoint": "weather"})
+        
+        # Log Trace
+        log_trace("mcp-weather", trace_id, span_id, "get_current_weather", duration, "ok")
+        
+        return {
+            "location": data.get("name"),
+            "condition": data["weather"][0]["description"],
+            "temperature": format_temp(temp, units),
+            "feels_like": format_temp(data["main"]["feels_like"], units),
+            "humidity": f"{data['main']['humidity']}%",
+            "wind_speed": f"{data['wind']['speed']} m/s",
+            "timestamp": data.get("dt")
+        }
+    except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-weather", trace_id, span_id, "get_current_weather", duration, "error")
+        return {"error": str(e)}
 
 @mcp.tool()
 def get_forecast(location: str, units: str = "metric") -> List[Dict[str, Any]]:

src/mcp-web/server.py

@@ -13,7 +13,9 @@ if src_dir not in sys.path:
 
 from mcp.server.fastmcp import FastMCP
 from typing import List, Dict, Any, Union
-from core.mcp_telemetry import log_usage
+from core.mcp_telemetry import log_usage, log_trace, log_metric
+import uuid
+import time
 
 # Local imports
 try:
@@ -48,8 +50,21 @@ def search(query: str, max_results: int = 5) -> List[Dict[str, Any]]:
     Search the web for the given query using DuckDuckGo.
     Returns a list of results with title, url, snippet.
     """
+    start_time = time.time()
+    trace_id = str(uuid.uuid4())
+    span_id = str(uuid.uuid4())
     log_usage("mcp-web", "search")
-    return search_web(query, max_results)
+    
+    try:
+        results = search_web(query, max_results)
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-web", trace_id, span_id, "search", duration, "ok")
+        log_metric("mcp-web", "search_results_count", len(results), {"query": query})
+        return results
+    except Exception as e:
+        duration = (time.time() - start_time) * 1000
+        log_trace("mcp-web", trace_id, span_id, "search", duration, "error")
+        raise e
 
 @mcp.tool()
 def extract(url: str) -> str: