Health Checks & Circuit Breaker

from flask import Flask, jsonify
import psycopg2

app = Flask(__name__)

@app.route('/health')
def health():
    return jsonify(status='healthy'), 200

# Advanced health check
@app.route('/health')
def health_detailed():
    try:
        # Check database
        conn = psycopg2.connect(DATABASE_URL)
        conn.close()

        return jsonify({
            'status': 'healthy',
            'timestamp': datetime.now().isoformat(),
            'services': {
                'database': 'up'
            }
        }), 200
    except Exception as e:
        return jsonify({
            'status': 'unhealthy',
            'error': str(e)
        }), 503

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

package main

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

type HealthResponse struct {
    Status    string    `json:"status"`
    Timestamp time.Time `json:"timestamp"`
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    json.NewEncoder(w).Encode(HealthResponse{
        Status:    "healthy",
        Timestamp: time.Now(),
    })
}

// Advanced health check
func healthDetailedHandler(w http.ResponseWriter, r *http.Request) {
    // Check database
    if err := db.Ping(); err != nil {
        w.WriteHeader(http.StatusServiceUnavailable)
        json.NewEncoder(w).Encode(map[string]string{
            "status": "unhealthy",
            "error":  err.Error(),
        })
        return
    }

    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "status":    "healthy",
        "timestamp": time.Now(),
        "services": map[string]string{
            "database": "up",
        },
    })
}

func main() {
    http.HandleFunc("/health", healthHandler)
    http.ListenAndServe(":8080", nil)
}

use axum::{
    routing::get,
    Json, Router,
};
use serde_json::{json, Value};

async fn health() -> Json<Value> {
    Json(json!({
        "status": "healthy"
    }))
}

// Advanced health check
async fn health_detailed() -> (StatusCode, Json<Value>) {
    // Check database connection
    match sqlx::query("SELECT 1").fetch_one(&pool).await {
        Ok(_) => (
            StatusCode::OK,
            Json(json!({
                "status": "healthy",
                "timestamp": chrono::Utc::now(),
                "services": {
                    "database": "up"
                }
            }))
        ),
        Err(e) => (
            StatusCode::SERVICE_UNAVAILABLE,
            Json(json!({
                "status": "unhealthy",
                "error": e.to_string()
            }))
        )
    }
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/health", get(health));

    axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}