pgSentinelAPI Reference

import requests
import json
from datetime import datetime, timedelta

class PgSentinelClient:
    def __init__(self, base_url="http://localhost:8000/api/v1"):
        self.base_url = base_url
        self.session = requests.Session()
    
    def get_health(self):
        """Get system health status"""
        response = self.session.get(f"{self.base_url}/health")
        return response.json()
    
    def get_metrics(self, start_time=None, end_time=None):
        """Get historical metrics"""
        params = {}
        if start_time:
            params['start_time'] = start_time.isoformat()
        if end_time:
            params['end_time'] = end_time.isoformat()
        
        response = self.session.get(f"{self.base_url}/metrics/history", params=params)
        return response.json()
    
    def get_query_insights(self, limit=20):
        """Get query performance insights"""
        response = self.session.get(f"{self.base_url}/insights/queries", 
                                  params={'limit': limit})
        return response.json()

# Usage
client = PgSentinelClient()
health = client.get_health()
print(f"System status: {health['status']}")

# Get metrics for last hour
end_time = datetime.now()
start_time = end_time - timedelta(hours=1)
metrics = client.get_metrics(start_time, end_time)
print(f"Data points: {len(metrics['data'])}")

class PgSentinelClient {
    constructor(baseUrl = 'http://localhost:8000/api/v1') {
        this.baseUrl = baseUrl;
    }
    
    async request(endpoint, options = {}) {
        const url = `${this.baseUrl}${endpoint}`;
        const response = await fetch(url, {
            headers: {
                'Content-Type': 'application/json',
                ...options.headers
            },
            ...options
        });
        
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        return response.json();
    }
    
    async getHealth() {
        return this.request('/health');
    }
    
    async getMetrics(startTime, endTime) {
        const params = new URLSearchParams();
        if (startTime) params.append('start_time', startTime.toISOString());
        if (endTime) params.append('end_time', endTime.toISOString());
        
        return this.request(`/metrics/history?${params}`);
    }
    
    async getQueryInsights(limit = 20) {
        return this.request(`/insights/queries?limit=${limit}`);
    }
    
    // WebSocket connection for real-time data
    connectWebSocket(onMessage) {
        const ws = new WebSocket('ws://localhost:8000/ws/live');
        
        ws.onmessage = (event) => {
            const data = JSON.parse(event.data);
            onMessage(data);
        };
        
        return ws;
    }
}

// Usage
const client = new PgSentinelClient();

// Get system health
client.getHealth().then(health => {
    console.log('System status:', health.status);
});

// Connect to real-time updates
const ws = client.connectWebSocket((data) => {
    console.log('Real-time update:', data);
});

# Get system health
curl -X GET "http://localhost:8000/api/v1/health" \
  -H "Content-Type: application/json"

# Get real-time metrics
curl -X GET "http://localhost:8000/api/v1/metrics/live" \
  -H "Content-Type: application/json"

# Get query insights
curl -X GET "http://localhost:8000/api/v1/insights/queries?limit=10" \
  -H "Content-Type: application/json"

# Get historical metrics
curl -X GET "http://localhost:8000/api/v1/metrics/history?start_time=2024-01-15T09:00:00Z&interval=5m" \
  -H "Content-Type: application/json"

# Reload pgbalancer configuration
curl -X POST "http://localhost:8000/api/v1/pgbalancer/reload" \
  -H "Content-Type: application/json"

# Get table statistics
curl -X GET "http://localhost:8000/api/v1/insights/tables" \
  -H "Content-Type: application/json"