Analytics

from functor_sdk import FunctorClient

client = FunctorClient(api_key="your-api-key")

# Get usage summary for a date range
summary = client.analytics.get_usage_summary(
    start_date="2024-01-01",
    end_date="2024-01-31"
)

print(f"Total requests: {summary['total_requests']}")
print(f"Total tokens: {summary['total_tokens']}")
print(f"Average latency: {summary['avg_latency_ms']}ms")

# Calculate estimated costs
costs = client.analytics.get_cost_estimate(
    start_date="2024-01-01",
    end_date="2024-01-31",
    user_id="user_123"  # Optional: filter by user
)

print(f"Total cost: ${costs['total_cost_usd']:.2f}")
print(f"LLM cost: ${costs['llm_cost']:.2f}")
print(f"Embedding cost: ${costs['embedding_cost']:.2f}")

# Get detailed trace information
trace = client.analytics.get_trace("trace_abc123")

print(f"Endpoint: {trace['endpoint']}")
print(f"Duration: {trace['duration_ms']}ms")
print(f"Status: {trace['status_code']}")

# Analyze operations
for op in trace['operations']:
    print(f"  {op['operation']}: {op['duration_ms']}ms")

# Retrieve session-level analytics
sessions = client.analytics.get_sessions(
    limit=50,
    offset=0,
    user_id="user_123"  # Optional: filter by user
)

for session in sessions['sessions']:
    print(f"Session {session['session_id']}")
    print(f"  Requests: {session['request_count']}")
    print(f"  Avg latency: {session['avg_latency_ms']}ms")
    print(f"  Total tokens: {session['total_tokens']}")

# Submit user feedback for a trace
response = client.analytics.submit_feedback(
    trace_id="trace_abc123",
    rating=5,
    comment="Excellent response quality and accuracy",
    metadata={"category": "accuracy"}
)

print(response.message)  # "Feedback submitted successfully"

summary = client.analytics.get_usage_summary(
    start_date="2024-01-01",    # Optional: Start date (ISO 8601)
    end_date="2024-01-31",      # Optional: End date (ISO 8601)
    user_id="user_123",         # Optional: Filter by user
    tenant_id="tenant_abc"      # Optional: Filter by tenant
)

costs = client.analytics.get_cost_estimate(
    start_date="2024-01-01",    # Optional: Start date
    end_date="2024-01-31",      # Optional: End date
    user_id="user_123",         # Optional: Filter by user
    tenant_id="tenant_abc"      # Optional: Filter by tenant
)

trace = client.analytics.get_trace(
    trace_id="trace_abc123"     # Required: Trace ID
)

sessions = client.analytics.get_sessions(
    limit=50,                   # Optional: Max results (default: 50)
    offset=0,                   # Optional: Pagination offset (default: 0)
    user_id="user_123",         # Optional: Filter by user
    tenant_id="tenant_abc"      # Optional: Filter by tenant
)

response = client.analytics.submit_feedback(
    trace_id="trace_abc123",    # Required: Trace ID
    rating=5,                   # Required: Rating (typically 1-5)
    comment="Great response",   # Optional: Text comment
    metadata={"key": "value"}   # Optional: Additional metadata
)

from datetime import datetime, timedelta

def create_cost_dashboard(days=30):
    client = FunctorClient()
    
    end_date = datetime.now().strftime("%Y-%m-%d")
    start_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
    
    # Get usage summary
    summary = client.analytics.get_usage_summary(
        start_date=start_date,
        end_date=end_date
    )
    
    # Get cost estimate
    costs = client.analytics.get_cost_estimate(
        start_date=start_date,
        end_date=end_date
    )
    
    dashboard = {
        "period": f"{start_date} to {end_date}",
        "total_requests": summary['total_requests'],
        "total_tokens": summary['total_tokens'],
        "total_cost": costs['total_cost_usd'],
        "llm_cost": costs['llm_cost'],
        "embedding_cost": costs['embedding_cost'],
        "cost_per_request": costs['total_cost_usd'] / max(summary['total_requests'], 1),
        "tokens_per_request": summary['total_tokens'] / max(summary['total_requests'], 1)
    }
    
    return dashboard

# Usage
dashboard = create_cost_dashboard(days=7)
print(f"Weekly Dashboard ({dashboard['period']})")
print(f"Total requests: {dashboard['total_requests']}")
print(f"Total cost: ${dashboard['total_cost']:.2f}")
print(f"Cost per request: ${dashboard['cost_per_request']:.4f}")

def analyze_trace_performance(trace_id):
    client = FunctorClient()
    
    trace = client.analytics.get_trace(trace_id)
    
    analysis = {
        "total_duration": trace['duration_ms'],
        "status": trace['status_code'],
        "endpoint": trace['endpoint'],
        "operations": []
    }
    
    # Analyze each operation
    for op in trace['operations']:
        op_analysis = {
            "name": op['operation'],
            "duration": op['duration_ms'],
            "percentage": (op['duration_ms'] / trace['duration_ms']) * 100
        }
        analysis['operations'].append(op_analysis)
    
    # Sort by duration
    analysis['operations'].sort(key=lambda x: x['duration'], reverse=True)
    
    # Find bottlenecks
    analysis['bottleneck'] = analysis['operations'][0]['name']
    
    return analysis

# Usage
analysis = analyze_trace_performance("trace_abc123")
print(f"Total duration: {analysis['total_duration']}ms")
print(f"Bottleneck: {analysis['bottleneck']}")
for op in analysis['operations'][:3]:
    print(f"  {op['name']}: {op['duration']}ms ({op['percentage']:.1f}%)")

def monitor_session_performance(user_id=None):
    client = FunctorClient()
    
    sessions = client.analytics.get_sessions(
        limit=100,
        user_id=user_id
    )
    
    metrics = {
        "total_sessions": len(sessions['sessions']),
        "total_requests": 0,
        "avg_latency": 0,
        "high_latency_sessions": []
    }
    
    latencies = []
    for session in sessions['sessions']:
        metrics['total_requests'] += session['request_count']
        latencies.append(session['avg_latency_ms'])
        
        if session['avg_latency_ms'] > 1000:  # > 1 second
            metrics['high_latency_sessions'].append({
                "session_id": session['session_id'],
                "latency": session['avg_latency_ms'],
                "requests": session['request_count']
            })
    
    metrics['avg_latency'] = sum(latencies) / len(latencies) if latencies else 0
    
    return metrics

# Usage
metrics = monitor_session_performance()
print(f"Sessions analyzed: {metrics['total_sessions']}")
print(f"Average latency: {metrics['avg_latency']:.1f}ms")
print(f"High latency sessions: {len(metrics['high_latency_sessions'])}")

import asyncio
from functor_sdk import FunctorClient

async def gather_analytics_data():
    async with FunctorClient() as client:
        # Run multiple analytics queries concurrently
        tasks = [
            client.analytics.get_usage_summary_async(
                start_date="2024-01-01"
            ),
            client.analytics.get_cost_estimate_async(
                start_date="2024-01-01"
            ),
            client.analytics.get_sessions_async(limit=50)
        ]
        
        summary, costs, sessions = await asyncio.gather(*tasks)
        
        return {
            "summary": summary,
            "costs": costs,
            "sessions": sessions
        }

# Usage
data = asyncio.run(gather_analytics_data())
print(f"Requests: {data['summary']['total_requests']}")
print(f"Costs: ${data['costs']['total_cost_usd']:.2f}")
print(f"Sessions: {len(data['sessions']['sessions'])}")