feat(instance): метрики и healthcheck инстанса для дашборда

Раздел «Инстанс» получает живые показатели сервера (AGENT.md 7.19).

- `internal/sysinfo`: загрузка процессора по cgroup v2 (`cpu.stat`/`cpu.max`)
  с откатом на `/proc/stat`, память по лимиту контейнера либо `/proc/meminfo`,
  место на разделе данных и размер базы вместе с журналом WAL;
- `GET /api/v1/instance/metrics` (только администратор инстанса): метрики,
  состояние (`ok|warn|failed`), проверки app/database/disk/storage/voice/
  gateway, версия и время работы; недоступные источники не ломают ответ, а
  попадают в проверку `metrics`;
- тяжёлые проверки (БД, SFU, запись) кэшируются на 5 секунд: ручку можно
  опрашивать раз в секунду;
- `voice.IssueRoomList` и `AdminClient.Ping` проверяют доступность RoomService
  и валидность ключей LiveKit (та же связка, что ломала модерацию);
- у метрик свой лимит частоты, они исключены из общего лимита API
  (`RateLimiter.MiddlewareExcept`), иначе открытый раздел съедал бы половину
  бюджета запросов;
- тесты: `internal/sysinfo` (cgroup, /proc, память, диск, размеры файлов) и
  `internal/server/api_metrics_test.go` (доступ, состав метрик, кэш, 429).

internal/server/api_metrics.go

@@ -0,0 +1,313 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/danielgtaylor/huma/v2"
+
+	"glchat/internal/sysinfo"
+)
+
+// metricsPath — ручка живого дашборда инстанса. Вынесена в константу: её
+// опрос раз в секунду исключён из общего лимита API (см. registerRoutes).
+const metricsPath = "/api/v1/instance/metrics"
+
+// healthCacheTTL — как долго переиспользуются результаты тяжёлых проверок
+// (запрос к БД и к SFU). Метрики при этом считаются на каждый запрос, поэтому
+// ручку можно опрашивать раз в секунду.
+const healthCacheTTL = 5 * time.Second
+
+// healthCache хранит последний healthcheck: дашборд обновляется раз в секунду,
+// а проверки с сетевыми вызовами чаще раза в healthCacheTTL не нужны.
+type healthCache struct {
+	mu     sync.Mutex
+	checks []metricsCheck
+	at     time.Time
+}
+
+type metricsCPU struct {
+	Percent float64 `json:"percent" doc:"Загрузка процессора в процентах от доступного времени"`
+	Cores   float64 `json:"cores" doc:"Доступные ядра (лимит контейнера или ядра хоста)"`
+	Source  string  `json:"source" doc:"Источник данных: cgroup или host"`
+}
+
+type metricsMemory struct {
+	UsedBytes  int64   `json:"used_bytes"`
+	TotalBytes int64   `json:"total_bytes"`
+	Percent    float64 `json:"percent"`
+	Source     string  `json:"source" doc:"Источник данных: cgroup (лимит) или host"`
+}
+
+type metricsDisk struct {
+	UsedBytes  int64 `json:"used_bytes"`
+	TotalBytes int64 `json:"total_bytes"`
+	FreeBytes  int64 `json:"free_bytes"`
+}
+
+type metricsDatabase struct {
+	Bytes    int64 `json:"bytes" doc:"Размер файла базы"`
+	WalBytes int64 `json:"wal_bytes" doc:"Размер журнала WAL"`
+}
+
+// metricsCheck — одна проверка инстанса. name и status машиночитаемые, текст
+// сообщения технический (локализуется на клиенте по name).
+type metricsCheck struct {
+	Name    string `json:"name"`
+	Status  string `json:"status" enum:"ok,warn,failed,off"`
+	Message string `json:"message,omitempty"`
+}
+
+type metricsPayload struct {
+	CPU           metricsCPU      `json:"cpu"`
+	Memory        metricsMemory   `json:"memory"`
+	Disk          metricsDisk     `json:"disk"`
+	Database      metricsDatabase `json:"database"`
+	Checks        []metricsCheck  `json:"checks"`
+	Health        string          `json:"health" enum:"ok,warn,failed"`
+	UptimeSeconds int64           `json:"uptime_seconds"`
+	Version       string          `json:"version"`
+	Commit        string          `json:"commit"`
+	CollectedAt   string          `json:"collected_at"`
+}
+
+type metricsOutput struct {
+	Body struct {
+		Metrics metricsPayload `json:"metrics"`
+	}
+}
+
+// registerMetricsRoutes описывает дашборд инстанса: живые метрики, состояние
+// диска и базы, healthcheck и версия (AGENT.md 7.19).
+func (s *Server) registerMetricsRoutes(api huma.API) {
+	huma.Register(api, huma.Operation{
+		OperationID: "getInstanceMetrics",
+		Method:      http.MethodGet,
+		Path:        "/instance/metrics",
+		Summary:     "Живые метрики инстанса (только администратор)",
+		Tags:        []string{"Instance"},
+		Security:    []map[string][]string{{"sessionCookie": {}}, {"bearerAuth": {}}},
+	}, func(ctx context.Context, _ *struct{}) (*metricsOutput, error) {
+		user, _, err := requireUser(ctx)
+		if err != nil {
+			return nil, err
+		}
+		if !user.IsInstanceAdmin {
+			return nil, humaErrorStatus(http.StatusForbidden, "perm.denied", "instance admin is required")
+		}
+		// Свой лимит: раз в секунду — это 60 запросов в минуту, под общим
+		// лимитом API такой опрос съедал бы половину бюджета (AGENT.md 8.6).
+		if allowed, retryAfter := s.metricsLimiter.Allow("metrics:" + formatSnowflake(user.ID)); !allowed {
+			return nil, rateLimitedError(retryAfter)
+		}
+
+		output := &metricsOutput{}
+		output.Body.Metrics = s.collectMetrics(ctx)
+		return output, nil
+	})
+}
+
+// collectMetrics собирает метрики и (при необходимости) обновляет healthcheck.
+// Недоступные источники не ломают ответ: они попадают в проверку «metrics»,
+// а соответствующий блок остаётся пустым (так ведёт себя, например, macOS без
+// cgroup и /proc).
+func (s *Server) collectMetrics(ctx context.Context) metricsPayload {
+	payload := metricsPayload{
+		UptimeSeconds: int64(time.Since(startedAt).Seconds()),
+		Version:       s.cfg.Version,
+		Commit:        s.cfg.Commit,
+		CollectedAt:   time.Now().UTC().Format(time.RFC3339Nano),
+	}
+	var problems []string
+
+	if s.cpuSampler == nil {
+		problems = append(problems, "cpu: sampler is not configured")
+	} else if percent, cores, source, err := s.cpuSampler.CPUPercent(); err != nil {
+		problems = append(problems, "cpu: "+err.Error())
+	} else {
+		payload.CPU = metricsCPU{Percent: round1(percent), Cores: cores, Source: source}
+	}
+
+	if memory, err := sysinfo.ReadMemory(s.sysinfoPaths); err != nil {
+		problems = append(problems, "memory: "+err.Error())
+	} else {
+		payload.Memory = metricsMemory{
+			UsedBytes:  memory.UsedBytes,
+			TotalBytes: memory.TotalBytes,
+			Percent:    round1(memory.Percent()),
+			Source:     memory.Source,
+		}
+	}
+
+	if disk, err := sysinfo.ReadDisk(s.cfg.DataDir); err != nil {
+		problems = append(problems, "disk: "+err.Error())
+	} else {
+		payload.Disk = metricsDisk{
+			UsedBytes:  disk.UsedBytes,
+			TotalBytes: disk.TotalBytes,
+			FreeBytes:  disk.FreeBytes,
+		}
+	}
+
+	dbPath := s.databasePath()
+	payload.Database = metricsDatabase{
+		Bytes: sysinfo.FileBytes(dbPath),
+		// WAL живёт рядом с базой и в пике бывает больше её самой.
+		WalBytes: sysinfo.FileBytes(dbPath + "-wal"),
+	}
+
+	payload.Checks = s.instanceChecks(ctx, problems)
+	payload.Health = summarizeHealth(payload.Checks)
+	return payload
+}
+
+// databasePath возвращает путь к файлу базы: в конфиге он может быть не задан
+// (сборка конфига вручную, тесты), тогда берём его у открытой базы.
+func (s *Server) databasePath() string {
+	if s.cfg.DatabasePath != "" {
+		return s.cfg.DatabasePath
+	}
+	if s.db != nil {
+		return s.db.Path()
+	}
+	return ""
+}
+
+// instanceChecks отдаёт проверки инстанса из кэша либо пересчитывает их.
+func (s *Server) instanceChecks(ctx context.Context, problems []string) []metricsCheck {
+	s.health.mu.Lock()
+	defer s.health.mu.Unlock()
+	if s.health.checks == nil || time.Since(s.health.at) >= healthCacheTTL {
+		s.health.checks = s.buildChecks(ctx)
+		s.health.at = time.Now()
+	}
+	if len(problems) == 0 {
+		return s.health.checks
+	}
+	// Проблемы с источниками метрик показываем отдельной проверкой, не затирая
+	// кэш: причина обычно постоянная (нет cgroup), а не разовая.
+	checks := make([]metricsCheck, 0, len(s.health.checks)+1)
+	checks = append(checks, s.health.checks...)
+	checks = append(checks, metricsCheck{
+		Name:    "metrics",
+		Status:  "warn",
+		Message: strings.Join(problems, "; "),
+	})
+	return checks
+}
+
+// buildChecks выполняет проверки: приложение, база, диск, SFU, Gateway.
+func (s *Server) buildChecks(ctx context.Context) []metricsCheck {
+	checks := []metricsCheck{{
+		Name:    "app",
+		Status:  "ok",
+		Message: s.cfg.Version,
+	}}
+
+	// База: ping и версия схемы (миграции применяются при старте).
+	if s.db != nil {
+		checkCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
+		if err := s.db.Ready(checkCtx); err != nil {
+			checks = append(checks, metricsCheck{Name: "database", Status: "failed", Message: err.Error()})
+		} else {
+			version, err := s.db.SchemaVersion(checkCtx)
+			switch {
+			case err != nil:
+				checks = append(checks, metricsCheck{Name: "database", Status: "warn", Message: err.Error()})
+			default:
+				checks = append(checks, metricsCheck{
+					Name:    "database",
+					Status:  "ok",
+					Message: fmt.Sprintf("schema_version=%d", version),
+				})
+			}
+		}
+		cancel()
+	} else {
+		checks = append(checks, metricsCheck{Name: "database", Status: "off"})
+	}
+
+	// Диск: предупреждаем заранее, до заполнения раздела.
+	if disk, err := sysinfo.ReadDisk(s.cfg.DataDir); err != nil {
+		checks = append(checks, metricsCheck{Name: "disk", Status: "warn", Message: err.Error()})
+	} else {
+		status := "ok"
+		switch freePercent := float64(disk.FreeBytes) / float64(disk.TotalBytes) * 100; {
+		case freePercent < 5:
+			status = "failed"
+		case freePercent < 15:
+			status = "warn"
+		}
+		checks = append(checks, metricsCheck{
+			Name:    "disk",
+			Status:  status,
+			Message: fmt.Sprintf("%.1f%% free", float64(disk.FreeBytes)/float64(disk.TotalBytes)*100),
+		})
+	}
+
+	// Запись в каталог данных: база, вложения и звуки должны быть записываемы.
+	checks = append(checks, s.checkDataWritable())
+
+	// SFU: заодно проверяются ключи LiveKit — их неверность ломает модерацию.
+	switch {
+	case !s.voice.Enabled():
+		checks = append(checks, metricsCheck{Name: "voice", Status: "off"})
+	case !s.voiceAdmin.Enabled():
+		checks = append(checks, metricsCheck{Name: "voice", Status: "off", Message: "api url is not set"})
+	default:
+		checkCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
+		defer cancel()
+		if err := s.voiceAdmin.Ping(checkCtx); err != nil {
+			checks = append(checks, metricsCheck{Name: "voice", Status: "failed", Message: err.Error()})
+		} else {
+			checks = append(checks, metricsCheck{Name: "voice", Status: "ok", Message: "RoomService"})
+		}
+	}
+
+	if s.gateway != nil {
+		checks = append(checks, metricsCheck{
+			Name:    "gateway",
+			Status:  "ok",
+			Message: fmt.Sprintf("sessions=%d", s.gateway.ActiveSessions()),
+		})
+	}
+	return checks
+}
+
+// checkDataWritable проверяет, что в каталоге данных можно создавать файлы.
+func (s *Server) checkDataWritable() metricsCheck {
+	probe := filepath.Join(s.cfg.DataDir, ".healthcheck")
+	// Путь собирается из каталога данных инстанса, а не из пользовательского ввода.
+	file, err := os.OpenFile(probe, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600) //nolint:gosec // каталог данных задаёт конфигурация
+	if err != nil {
+		return metricsCheck{Name: "storage", Status: "failed", Message: err.Error()}
+	}
+	_ = file.Close()
+	_ = os.Remove(probe)
+	return metricsCheck{Name: "storage", Status: "ok"}
+}
+
+// summarizeHealth сводит проверки к общему состоянию: failed → failed,
+// warn/off пропускаем как «не критично», иначе ok.
+func summarizeHealth(checks []metricsCheck) string {
+	summary := "ok"
+	for _, check := range checks {
+		switch check.Status {
+		case "failed":
+			return "failed"
+		case "warn":
+			summary = "warn"
+		}
+	}
+	return summary
+}
+
+func round1(value float64) float64 {
+	return float64(int(value*10+0.5)) / 10
+}

internal/server/api_metrics_test.go

@@ -0,0 +1,179 @@
+package server
+
+import (
+	"net/http"
+	"testing"
+	"time"
+
+	"glchat/internal/httpx"
+)
+
+// Тесты дашборда инстанса: доступ только администратору, состав метрик и
+// healthcheck, отдельный лимит частоты для опроса раз в секунду (AGENT.md 7.19).
+
+type metricsBody struct {
+	Metrics struct {
+		CPU struct {
+			Percent float64 `json:"percent"`
+			Cores   float64 `json:"cores"`
+			Source  string  `json:"source"`
+		} `json:"cpu"`
+		Memory struct {
+			UsedBytes  int64   `json:"used_bytes"`
+			TotalBytes int64   `json:"total_bytes"`
+			Percent    float64 `json:"percent"`
+			Source     string  `json:"source"`
+		} `json:"memory"`
+		Disk struct {
+			UsedBytes  int64 `json:"used_bytes"`
+			TotalBytes int64 `json:"total_bytes"`
+			FreeBytes  int64 `json:"free_bytes"`
+		} `json:"disk"`
+		Database struct {
+			Bytes    int64 `json:"bytes"`
+			WalBytes int64 `json:"wal_bytes"`
+		} `json:"database"`
+		Checks []struct {
+			Name    string `json:"name"`
+			Status  string `json:"status"`
+			Message string `json:"message"`
+		} `json:"checks"`
+		Health        string `json:"health"`
+		UptimeSeconds int64  `json:"uptime_seconds"`
+		Version       string `json:"version"`
+		Commit        string `json:"commit"`
+		CollectedAt   string `json:"collected_at"`
+	} `json:"metrics"`
+}
+
+// metricsServer готовит сервер с настоящими источниками метрик (cgroup/proc
+// текущей машины) — тесты проверяют и разбор, и отдачу значений.
+func metricsServer(t *testing.T) (*Server, *http.Cookie) {
+	t.Helper()
+	srv, _ := newTestServer(t)
+	cookie := registerAndLogin(t, srv, "metrics_admin", "metrics@example.com")
+	promoteAdmin(t, srv, "metrics@example.com")
+	return srv, cookie
+}
+
+func TestInstanceMetricsRequireAdmin(t *testing.T) {
+	srv, _ := newTestServer(t)
+	member := registerAndLogin(t, srv, "metrics_member", "metrics-member@example.com")
+
+	rec := doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", member)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("обычный участник: статус %d, ожидался 403", rec.Code)
+	}
+	anonymous := doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "")
+	if anonymous.Code != http.StatusUnauthorized {
+		t.Fatalf("без сессии: статус %d, ожидался 401", anonymous.Code)
+	}
+}
+
+func TestInstanceMetricsPayload(t *testing.T) {
+	srv, cookie := metricsServer(t)
+	// Первый вызов только снимает показания процессора, второй считает дельту.
+	doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)
+	time.Sleep(20 * time.Millisecond)
+
+	rec := doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("статус = %d, тело = %s", rec.Code, rec.Body.String())
+	}
+	payload := decodeResponse[metricsBody](t, rec).Metrics
+
+	if payload.Version == "" || payload.Commit != "deadbee" {
+		t.Fatalf("версия/коммит = %q/%q", payload.Version, payload.Commit)
+	}
+	if payload.UptimeSeconds < 0 || payload.CollectedAt == "" {
+		t.Fatalf("время работы/сбора = %d/%q", payload.UptimeSeconds, payload.CollectedAt)
+	}
+	// На macOS нет ни cgroup, ни /proc: источник недоступен, и ручка обязана
+	// деградировать мягко (проверка «metrics» в статусе warn).
+	switch payload.CPU.Source {
+	case "":
+		t.Log("источники процессора недоступны (не Linux) — проверка пропущена")
+	case "cgroup", "host":
+		if payload.CPU.Percent < 0 || payload.CPU.Percent > 100 || payload.CPU.Cores <= 0 {
+			t.Fatalf("процессор = %+v", payload.CPU)
+		}
+	default:
+		t.Fatalf("неизвестный источник процессора = %q", payload.CPU.Source)
+	}
+	if payload.Memory.TotalBytes == 0 {
+		t.Log("память недоступна (не Linux) — проверка пропущена")
+	} else if payload.Memory.UsedBytes <= 0 || payload.Memory.Percent <= 0 || payload.Memory.Percent > 100 {
+		t.Fatalf("память = %+v", payload.Memory)
+	}
+	if payload.Disk.TotalBytes <= 0 || payload.Disk.UsedBytes <= 0 || payload.Disk.FreeBytes <= 0 {
+		t.Fatalf("диск = %+v", payload.Disk)
+	}
+	if payload.Database.Bytes <= 0 {
+		t.Fatalf("размер базы = %d", payload.Database.Bytes)
+	}
+
+	// Healthcheck: приложение, база, диск, запись, gateway.
+	statuses := map[string]string{}
+	for _, check := range payload.Checks {
+		statuses[check.Name] = check.Status
+	}
+	for _, name := range []string{"app", "database", "disk", "storage", "gateway"} {
+		if statuses[name] != "ok" {
+			t.Fatalf("проверка %s = %q (все: %+v)", name, statuses[name], payload.Checks)
+		}
+	}
+	// На Linux без cgroup/proc не бывает, поэтому «metrics» появляется только
+	// на не-Linux: тогда health = warn, иначе ok.
+	if statuses["metrics"] == "warn" {
+		if payload.Health != "warn" {
+			t.Fatalf("состояние = %q при проблеме с метриками", payload.Health)
+		}
+	} else if payload.Health != "ok" {
+		t.Fatalf("итоговое состояние = %q, проверки: %+v", payload.Health, payload.Checks)
+	}
+}
+
+func TestInstanceMetricsRateLimitIsSeparate(t *testing.T) {
+	srv, cookie := metricsServer(t)
+	// Лимит дашборда — 120/мин с запасом 30: серия из 40 запросов проходит,
+	// хотя общий лимит API (120/мин) в тестах уже израсходован регистрацией.
+	for i := 0; i < 25; i++ {
+		rec := doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("запрос %d: статус %d (%s)", i+1, rec.Code, rec.Body.String())
+		}
+	}
+
+	// Исчерпание своего лимита даёт 429 с подсказкой по паузе: ставим лимитер
+	// на один запрос и расходуем токен.
+	srv.metricsLimiter = httpx.NewRateLimiterWindow(1, time.Hour, 1)
+	doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)
+	rec := doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)
+	if rec.Code != http.StatusTooManyRequests {
+		t.Fatalf("статус = %d, ожидался 429", rec.Code)
+	}
+	payload := decodeResponse[struct {
+		Error struct {
+			Code         string `json:"code"`
+			RetryAfterMS int    `json:"retry_after_ms"`
+		} `json:"error"`
+	}](t, rec)
+	if payload.Error.Code != "rate_limited" || payload.Error.RetryAfterMS <= 0 {
+		t.Fatalf("ошибка = %+v", payload.Error)
+	}
+}
+
+func TestInstanceMetricsHealthCacheReusesChecks(t *testing.T) {
+	srv, cookie := metricsServer(t)
+	first := decodeResponse[metricsBody](t, doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)).Metrics
+	second := decodeResponse[metricsBody](t, doJSON(t, srv, http.MethodGet, "/api/v1/instance/metrics", "", cookie)).Metrics
+
+	if len(first.Checks) != len(second.Checks) {
+		t.Fatalf("набор проверок изменился: %d → %d", len(first.Checks), len(second.Checks))
+	}
+	// Проверки берутся из кэша (TTL 5 секунд) — время сбора метрик при этом
+	// обновляется на каждом запросе.
+	if first.CollectedAt == second.CollectedAt {
+		t.Fatal("метрики должны пересчитываться на каждый запрос")
+	}
+}

internal/server/server.go

@@ -22,6 +22,7 @@ import (
 	"glchat/internal/permissions"
 	"glchat/internal/source"
 	"glchat/internal/store"
+	"glchat/internal/sysinfo"
 	"glchat/internal/voice"
 )
 
@@ -66,6 +67,13 @@ type Server struct {
 	voice *voice.TokenIssuer
 	// voiceAdmin — RoomService для модерации на стороне SFU.
 	voiceAdmin *voice.AdminClient
+	// sysinfoPaths и cpuSampler — источники живых метрик дашборда инстанса.
+	sysinfoPaths sysinfo.Paths
+	cpuSampler   *sysinfo.Sampler
+	// metricsLimiter — отдельный лимит для ручки метрик (опрос раз в секунду).
+	metricsLimiter *httpx.RateLimiter
+	// health — кэш тяжёлых проверок инстанса.
+	health healthCache
 	// presence — время последнего обновления last_seen по пользователю.
 	presenceMu sync.Mutex
 	presence   map[uint64]time.Time
@@ -101,9 +109,13 @@ func New(cfg config.Config, db *database.DB, logger *slog.Logger, deps Deps) *Se
 		slowmode:          map[string]time.Time{},
 		presence:          map[uint64]time.Time{},
 		webhookSeen:       map[string]time.Time{},
-		voice:             voice.NewIssuer(cfg.LiveKitAPIKey, cfg.LiveKitAPISecret, cfg.LiveKitTokenTTL),
-		voiceAdmin:        voice.NewAdminClient(voice.NewIssuer(cfg.LiveKitAPIKey, cfg.LiveKitAPISecret, cfg.LiveKitTokenTTL), cfg.LiveKitAPIURL),
+		// Дашборд опрашивает метрики раз в секунду: 120/мин с запасом.
+		metricsLimiter: httpx.NewRateLimiter(120, 30),
+		sysinfoPaths:   sysinfo.DefaultPaths(),
+		voice:          voice.NewIssuer(cfg.LiveKitAPIKey, cfg.LiveKitAPISecret, cfg.LiveKitTokenTTL),
+		voiceAdmin:     voice.NewAdminClient(voice.NewIssuer(cfg.LiveKitAPIKey, cfg.LiveKitAPISecret, cfg.LiveKitTokenTTL), cfg.LiveKitAPIURL),
 	}
+	s.cpuSampler = sysinfo.NewSampler(s.sysinfoPaths)
 	switch {
 	case deps.Permissions != nil:
 		s.perms = deps.Permissions
@@ -115,7 +127,8 @@ func New(cfg config.Config, db *database.DB, logger *slog.Logger, deps Deps) *Se
 	router.Route("/api/v1", func(apiRouter chi.Router) {
 		// Сессия резолвится один раз на запрос: huma-ручки читают её из контекста.
 		apiRouter.Use(s.sessionContext)
-		apiRouter.Use(s.apiLimiter.Middleware(apiRateLimitKey))
+		// Метрики дашборда вне общего лимита: у них свой (см. api_metrics.go).
+		apiRouter.Use(s.apiLimiter.MiddlewareExcept(apiRateLimitKey, metricsPath))
 		s.api = s.registerAPI(apiRouter)
 		s.registerMetaRoutes(s.api)
 		s.registerAuthRoutes(apiRouter)
@@ -123,6 +136,7 @@ func New(cfg config.Config, db *database.DB, logger *slog.Logger, deps Deps) *Se
 			s.registerUserRoutes(s.api)
 			s.registerGuildRoutes(s.api)
 			s.registerInstanceRoutes(s.api)
+			s.registerMetricsRoutes(s.api)
 			s.registerMessageRoutes(s.api)
 			s.registerInviteRoutes(s.api)
 			s.registerFileRoutes(s.api, apiRouter)