/metrics Endpoint

curl http://localhost:8080/metrics

{
  "total_requests": 1547823,
  "successful_requests": 1542891,
  "failed_requests": 4932,
  "avg_response_time_ms": 12.45,
  "min_response_time_ms": 1.23,
  "max_response_time_ms": 234.56,
  "p50_response_time_ms": 10.12,
  "p95_response_time_ms": 28.45,
  "p99_response_time_ms": 45.67,
  "uptime_seconds": 86400,
  "requests_per_second": 17.91,
  "algorithm": "least-connections",
  "backends": [
    {
      "address": "192.168.1.10:8080",
      "healthy": true,
      "active_connections": 42,
      "total_requests": 515941,
      "failures": 0,
      "avg_response_time_ms": 11.23,
      "circuit_state": "closed"
    }
  ]
}

import requests
import json

response = requests.get('http://localhost:8080/metrics')
metrics = response.json()

print(f"Total Requests: {metrics['total_requests']}")
print(f"Success Rate: {metrics['successful_requests'] / metrics['total_requests'] * 100:.2f}%")
print(f"Avg Response Time: {metrics['avg_response_time_ms']:.2f}ms")
print(f"p95 Latency: {metrics['p95_response_time_ms']:.2f}ms")

# Check backend health
healthy_backends = sum(1 for b in metrics['backends'] if b['healthy'])
print(f"Healthy Backends: {healthy_backends}/{len(metrics['backends'])}")

const axios = require('axios');

async function getMetrics() {
  const response = await axios.get('http://localhost:8080/metrics');
  const metrics = response.data;

  console.log(`Total Requests: ${metrics.total_requests}`);
  console.log(`Success Rate: ${(metrics.successful_requests / metrics.total_requests * 100).toFixed(2)}%`);
  console.log(`Avg Response Time: ${metrics.avg_response_time_ms.toFixed(2)}ms`);

  // Check for unhealthy backends
  const unhealthy = metrics.backends.filter(b => !b.healthy);
  if (unhealthy.length > 0) {
    console.error(`Unhealthy backends: ${unhealthy.map(b => b.address).join(', ')}`);
  }
}

getMetrics();

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type Metrics struct {
    TotalRequests       int64   `json:"total_requests"`
    SuccessfulRequests  int64   `json:"successful_requests"`
    FailedRequests      int64   `json:"failed_requests"`
    AvgResponseTimeMs   float64 `json:"avg_response_time_ms"`
    P95ResponseTimeMs   float64 `json:"p95_response_time_ms"`
}

func main() {
    resp, _ := http.Get("http://localhost:8080/metrics")
    defer resp.Body.Close()

    var metrics Metrics
    json.NewDecoder(resp.Body).Decode(&metrics)

    successRate := float64(metrics.SuccessfulRequests) / float64(metrics.TotalRequests) * 100
    fmt.Printf("Total Requests: %d\n", metrics.TotalRequests)
    fmt.Printf("Success Rate: %.2f%%\n", successRate)
    fmt.Printf("Avg Response Time: %.2fms\n", metrics.AvgResponseTimeMs)
}

# Pretty print JSON
curl -s http://localhost:8080/metrics | jq

# Get specific metrics
RPS=$(curl -s http://localhost:8080/metrics | jq -r '.requests_per_second')
echo "Current RPS: $RPS"

# Check backend health
curl -s http://localhost:8080/metrics | jq -r '.backends[] | select(.healthy == false) | .address'

# Monitor metrics in real-time
watch -n 1 'curl -s http://localhost:8080/metrics | jq "{rps: .requests_per_second, latency: .avg_response_time_ms, healthy: [.backends[] | select(.healthy == true)] | length}"'

// React component example
import React, { useState, useEffect } from 'react';

function MetricsDashboard() {
  const [metrics, setMetrics] = useState(null);

  useEffect(() => {
    const fetchMetrics = async () => {
      const response = await fetch('http://localhost:8080/metrics');
      const data = await response.json();
      setMetrics(data);
    };

    fetchMetrics();
    const interval = setInterval(fetchMetrics, 5000); // Update every 5s

    return () => clearInterval(interval);
  }, []);

  if (!metrics) return <div>Loading...</div>;

  return (
    <div>
      <h2>UltraBalancer Metrics</h2>
      <div>RPS: {metrics.requests_per_second.toFixed(2)}</div>
      <div>Avg Latency: {metrics.avg_response_time_ms.toFixed(2)}ms</div>
      <div>Success Rate: {(metrics.successful_requests / metrics.total_requests * 100).toFixed(2)}%</div>
    </div>
  );
}

import requests
import time

METRICS_URL = "http://localhost:8080/metrics"
ERROR_THRESHOLD = 5.0  # 5% error rate
LATENCY_THRESHOLD = 500  # 500ms

while True:
    metrics = requests.get(METRICS_URL).json()

    # Check error rate
    error_rate = (metrics['failed_requests'] / metrics['total_requests']) * 100
    if error_rate > ERROR_THRESHOLD:
        print(f"ALERT: High error rate: {error_rate:.2f}%")

    # Check latency
    if metrics['p95_response_time_ms'] > LATENCY_THRESHOLD:
        print(f"ALERT: High latency: {metrics['p95_response_time_ms']:.2f}ms")

    # Check backend health
    unhealthy = [b for b in metrics['backends'] if not b['healthy']]
    if unhealthy:
        print(f"ALERT: Unhealthy backends: {[b['address'] for b in unhealthy]}")

    time.sleep(30)