// Go - 使用 client_golang
import "github.com/prometheus/client_golang/prometheus"

var httpRequestsTotal = prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "http_requests_total",
        Help: "Total number of HTTP requests",
    },
    []string{"method", "path", "status"},
)

func init() {
    prometheus.MustRegister(httpRequestsTotal)
}

func handler(w http.ResponseWriter, r *http.Request) {
    // 处理请求
    // ...
    // 计数
    httpRequestsTotal.WithLabelValues(r.Method, r.URL.Path, "200").Inc()
}

# Python - 使用 prometheus_client
from prometheus_client import Counter

http_requests_total = Counter(
    'http_requests_total',
    'Total number of HTTP requests',
    ['method', 'path', 'status']
)

def handle_request(method, path, status):
    http_requests_total.labels(method=method, path=path, status=status).inc()

// Java - 使用 micrometer
Counter httpRequests = Counter.builder("http_requests_total")
    .description("Total number of HTTP requests")
    .tag("method", "GET")
    .tag("path", "/api")
    .register(meterRegistry);

httpRequests.increment();

# 每秒请求速率（过去 5 分钟）
rate(http_requests_total[5m])

# 过去 1 小时的请求增量
increase(http_requests_total[1h])

# 按方法分组的请求速率
sum by (method) (rate(http_requests_total[5m]))

# 错误率（5xx 占比）
sum(rate(http_requests_total{status=~"5.."}[5m]))
/
sum(rate(http_requests_total[5m]))

var ordersCreated = prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "ecommerce_orders_created_total",
        Help: "Total number of orders created",
    },
    []string{"channel", "payment_method", "region"},
)

var orderAmount = prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "ecommerce_order_amount_total_cents",
        Help: "Total order amount in cents",
    },
    []string{"currency"},
)

# 每分钟订单创建速率
rate(ecommerce_orders_created_total[1m]) * 60

# 各渠道订单占比
sum by (channel) (rate(ecommerce_orders_created_total[5m]))
/
sum(rate(ecommerce_orders_created_total[5m]))

// Go
var inprogressRequests = prometheus.NewGauge(
    prometheus.GaugeOpts{
        Name: "http_requests_inprogress",
        Help: "Number of HTTP requests currently in progress",
    },
)

var cpuTemperature = prometheus.NewGaugeVec(
    prometheus.GaugeOpts{
        Name: "node_cpu_temperature_celsius",
        Help: "Current CPU temperature",
    },
    []string{"core"},
)

// 操作
inprogressRequests.Inc()      // 增加 1
inprogressRequests.Dec()      // 减少 1
inprogressRequests.Set(42.0)  // 设置为 42.0
inprogressRequests.Add(10.0)  // 增加 10
inprogressRequests.Sub(3.0)   // 减少 3

# Python
from prometheus_client import Gauge

inprogress = Gauge('http_requests_inprogress', 'In-progress requests')
connections = Gauge('db_connections_active', 'Active DB connections', ['pool'])

# 使用装饰器自动跟踪
@inprogress.track_inprogress()
def handle_request():
    pass

# 手动操作
connections.labels(pool='primary').set(15)
connections.labels(pool='replica').inc()

# 当前值
http_requests_inprogress

# 过去 1 小时的平均值
avg_over_time(http_requests_inprogress[1h])

# 过去 1 小时的最大值
max_over_time(http_requests_inprogress[1h])

# 过去 1 小时的变化量
delta(http_requests_inprogress[1h])

# 内存使用率百分比
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes)
/ node_memory_MemTotal_bytes * 100

var dbPoolSize = prometheus.NewGaugeVec(
    prometheus.GaugeOpts{
        Name: "db_pool_connections",
        Help: "Current number of connections in the pool",
    },
    []string{"pool", "state"},  // state: active, idle, waiting
)

// 使用回调获取连接池状态
go func() {
    for {
        stats := db.Stats()
        dbPoolSize.WithLabelValues("primary", "active").Set(float64(stats.ActiveConnections))
        dbPoolSize.WithLabelValues("primary", "idle").Set(float64(stats.IdleConnections))
        dbPoolSize.WithLabelValues("primary", "waiting").Set(float64(stats.WaitCount))
        time.Sleep(5 * time.Second)
    }
}()

// Go
var httpDuration = prometheus.NewHistogramVec(
    prometheus.HistogramOpts{
        Name:    "http_request_duration_seconds",
        Help:    "HTTP request duration in seconds",
        Buckets: []float64{0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0},
    },
    []string{"method", "path"},
)

// 记录耗时
timer := prometheus.NewTimer(prometheus.ObserverFunc(
    httpDuration.WithLabelValues("GET", "/api/users").Observe))
defer timer.ObserveDuration()

// 或直接观察
httpDuration.WithLabelValues("GET", "/api/users").Observe(0.25)

# Python
from prometheus_client import Histogram

http_duration = Histogram(
    'http_request_duration_seconds',
    'HTTP request duration',
    ['method', 'path'],
    buckets=[0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
)

# 使用装饰器
@http_duration.labels(method='GET', path='/api').time()
def handle_request():
    pass

# 手动观察
http_duration.labels(method='POST', path='/api').observe(0.35)

# P99 延迟（99分位数）
histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

# P95 延迟，按 path 分组
histogram_quantile(0.95,
  sum by (path, le) (rate(http_request_duration_seconds_bucket[5m]))
)

# 平均延迟
rate(http_request_duration_seconds_sum[5m])
/
rate(http_request_duration_seconds_count[5m])

# 请求速率
rate(http_request_duration_seconds_count[5m])

// Go
var httpDuration = prometheus.NewSummaryVec(
    prometheus.SummaryOpts{
        Name:       "http_request_duration_seconds",
        Help:       "HTTP request duration in seconds",
        Objectives: map[float64]float64{
            0.5:  0.05,   // P50，误差 5%
            0.9:  0.01,   // P90，误差 1%
            0.99: 0.001,  // P99，误差 0.1%
        },
        MaxAge:     10 * time.Minute,  // 滑动窗口
        AgeBuckets: 5,
    },
    []string{"method", "path"},
)

// ✅ 好的标签设计
var requests = prometheus.NewCounterVec(
    prometheus.CounterOpts{Name: "http_requests_total"},
    []string{"method", "path", "status"},  // 低基数
)

// ❌ 危险的标签设计
var requests = prometheus.NewCounterVec(
    prometheus.CounterOpts{Name: "http_requests_total"},
    []string{"method", "url", "user_id", "trace_id"},  // url/user_id 高基数！
)

package main

import (
    "log"
    "math/rand"
    "net/http"
    "time"

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

// 定义指标
var (
    httpRequestsTotal = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Namespace: "myapp",
            Name:      "http_requests_total",
            Help:      "Total HTTP requests",
        },
        []string{"method", "path", "status"},
    )

    httpRequestDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Namespace: "myapp",
            Name:      "http_request_duration_seconds",
            Help:      "HTTP request duration",
            Buckets:   prometheus.DefBuckets,
        },
        []string{"method", "path"},
    )

    activeConnections = promauto.NewGauge(
        prometheus.GaugeOpts{
            Namespace: "myapp",
            Name:      "active_connections",
            Help:      "Currently active connections",
        },
    )
)

// 中间件
func instrumentHandler(path string, next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        activeConnections.Inc()
        defer activeConnections.Dec()

        next(w, r)

        duration := time.Since(start).Seconds()
        httpRequestDuration.WithLabelValues(r.Method, path).Observe(duration)
        httpRequestsTotal.WithLabelValues(r.Method, path, "200").Inc()
    }
}

func main() {
    http.HandleFunc("/api/users", instrumentHandler("/api/users", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
        w.Write([]byte("users"))
    }))

    http.Handle("/metrics", promhttp.Handler())
    log.Fatal(http.ListenAndServe(":8080", nil))
}