# Python — client officiel prometheus_client, avec FastAPI
from fastapi import FastAPI, Request
from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST
from starlette.responses import Response
import time

app = FastAPI()

# Counter : ne fait qu'AUGMENTER (nombre de requêtes, erreurs, tâches traitées...)
REQUEST_COUNT = Counter(
    "http_requests_total", "Nombre total de requêtes HTTP",
    ["method", "path", "status"]
)

# Histogram : distribution de valeurs (latence, taille de payload) avec des "buckets"
REQUEST_LATENCY = Histogram(
    "http_request_duration_seconds", "Durée des requêtes HTTP",
    ["method", "path"],
    buckets=[0.01, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]
)

# Gauge : valeur qui peut monter OU descendre (connexions actives, taille de file d'attente)
IN_PROGRESS = Gauge("http_requests_in_progress", "Requêtes en cours de traitement")


@app.middleware("http")
async def prometheus_middleware(request: Request, call_next):
    IN_PROGRESS.inc()
    start = time.perf_counter()
    response = await call_next(request)
    duration = time.perf_counter() - start

    REQUEST_LATENCY.labels(request.method, request.url.path).observe(duration)
    REQUEST_COUNT.labels(request.method, request.url.path, response.status_code).inc()
    IN_PROGRESS.dec()
    return response


@app.get("/metrics")
def metrics():
    return Response(generate_latest(), media_type=CONTENT_TYPE_LATEST)

// Node.js — client officiel prom-client, avec Express
const client = require("prom-client");
const express = require("express");
const app = express();

const register = new client.Registry();
client.collectDefaultMetrics({ register });   // CPU, mémoire, event loop lag... automatiques

const httpRequestDuration = new client.Histogram({
  name: "http_request_duration_seconds",
  help: "Durée des requêtes HTTP",
  labelNames: ["method", "route", "status_code"],
  buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5],
});
register.registerMetric(httpRequestDuration);

app.use((req, res, next) => {
  const end = httpRequestDuration.startTimer();
  res.on("finish", () => {
    end({ method: req.method, route: req.path, status_code: res.statusCode });
  });
  next();
});

app.get("/metrics", async (req, res) => {
  res.set("Content-Type", register.contentType);
  res.end(await register.metrics());
});

Choisir le bon type de métrique :

Counter   -> requêtes totales, erreurs totales, octets envoyés   (uniquement croissant, reset au redémarrage)
Gauge     -> connexions actives, taille de file, température CPU (monte ET descend)
Histogram -> latence, taille de payload  (distribution en buckets, permet de calculer des percentiles côté serveur)
Summary   -> comme Histogram mais calcule les percentiles côté CLIENT (moins flexible en agrégation multi-instances)

# Métriques métier, pas seulement techniques — souvent le plus précieux en production
ORDERS_CREATED = Counter("orders_created_total", "Commandes créées", ["payment_method"])
CART_VALUE = Histogram("cart_value_euros", "Valeur des paniers", buckets=[10, 25, 50, 100, 250, 500])
ACTIVE_SESSIONS = Gauge("active_user_sessions", "Sessions utilisateur actives")

# Exemple d'utilisation dans une route métier
@app.post("/orders")
def create_order(payment_method: str, total: float):
    ORDERS_CREATED.labels(payment_method=payment_method).inc()
    CART_VALUE.observe(total)
    return {"status": "created"}