Plot city-level traffic activity from local GeoIP coordinates

Add event filters to traffic dialogs and mirror city database in Gitea
Fix traffic map zoom and add paginated history with local city GeoIP
2026-10-15 20:48:04 +03:00 · 2026-10-15 20:41:07 +03:00 · 2026-10-15 20:26:14 +03:00 · 2026-10-15 20:11:51 +03:00 · 2026-10-14 20:37:34 +03:00
18 changed files with 1475 additions and 53 deletions
--- a/README.md
+++ b/README.md
@@ -586,3 +586,108 @@ HTTP-проверки остаются в истории и возвращают
 новые правила сразу применяются и к старым записям. Срабатывания и решения
 CrowdSec, а также общие счётчики firewall, никогда не скрываются этим фильтром.
 Сетевые потоки по-прежнему хранятся только последним снимком, без истории.
+
+## Alpine LXC и Docker NPM/NPM+ (v0.23.0)
+
+Установщик агента поддерживает Linux **x86_64/amd64** с systemd или OpenRC
+(Alpine LXC). Для Alpine команда из настроек сначала устанавливает curl и
+CA-сертификаты, если curl отсутствует. Бинарник статический, без glibc;
+скачивание проверяется по SHA-256. OpenRC-служба включается в default runlevel
+и использует supervise-daemon: перезапускает агент после ошибки и обновления.
+Команды: `rc-service proxmox-dashboard-agent status/restart` (выберите одно
+действие). Журнал: `/var/log/proxmox-dashboard-agent.log`; его ротацию настройте
+средствами ОС. Удаление — штатным `scripts/uninstall-agent.sh`.
+
+Обновление пакетов ОС и управление systemd-службами из интерфейса остаются
+функциями Debian/Ubuntu/systemd; этот релиз добавляет установку и работу агента
+на OpenRC, а не эмуляцию systemd. Включённый сетевой сбор на Alpine ставит
+`conntrack-tools` через `apk add --no-cache`. Ограничения CAP_NET_ADMIN и
+сетевого namespace LXC сохраняются; никаких изменений конфигурации Proxmox,
+privileged/nesting, firewall или sysctl агент не делает.
+
+После выбора агента Docker-хоста и включения карты трафика агент автоматически:
+
+- проверяет стандартные каталоги NPM и NPM+;
+- находит запущенные контейнеры с nginx-proxy-manager/npmplus в имени образа
+  и определяет каталоги логов по mounts `/data`, включая именованные volumes
+  и вложенные bind mounts;
+- читает обычный формат NPM и формат NPM+ `access.log`, включая ротацию;
+- находит единственный контейнер образа `crowdsecurity/crowdsec` и выполняет
+  только `cscli alerts list` через локальный Docker socket. Docker CLI, новый
+  bouncer key и опубликованный LAPI не нужны. Если контейнера нет, используется
+  прежний локальный `cscli`.
+
+Поиск повторяется раз в минуту, поэтому пересоздание контейнеров подхватывается
+автоматически. При нескольких CrowdSec задайте точный контейнер вручную:
+`DASHBOARD_CROWDSEC_CONTAINER=имя` в `/etc/proxmox-dashboard-agent.env` и
+перезапустите агент. Каталог логов можно переопределить переменной
+`DASHBOARD_NPM_LOG_DIR=/путь/к/логам`; `off` выключает сбор трафика этого агента.
+Используется локальный `/var/run/docker.sock`; rootless/удалённые Docker engines
+и логи только в stdout этим обнаружением не поддерживаются.
+
+NPM+ должен действительно писать access-логи: включите `LOGROTATE=true` в его
+Compose и пересоздайте контейнер, если логирование выключено. Агент показывает
+подсказку при отсутствии логов, но не меняет Compose приложений. Это настройка
+[NPM+](https://github.com/ZoeyVid/NPMplus/blob/develop/README.md), а не Dashboard.
+Stream-логи NPM+ не считаются HTTP-запросами; сетевые потоки собираются conntrack.
+Как и раньше, первый запуск чтения начинается с конца существующих логов.
+
+## Интерактивная карта (v0.24.0)
+
+Карта трафика использует ту же настройку `proxmox-theme`, что и основной
+Dashboard. Кнопка солнца/луны меняет тему; выбор сохраняется в браузере.
+Светлая тема распространяется на карту, график, карточки и модальные окна.
+
+Масштаб карты — от 100% до 600%: кнопки +/−, колесо мыши или жест двумя
+пальцами. Увеличенную карту можно перетаскивать; ↺ возвращает весь мир.
+При фокусе на карте доступны клавиши +/−, 0 и стрелки. Наведение подсвечивает
+контур страны и показывает суточные счётчики, а нажатие открывает подробности.
+
+Четыре карточки статистики открывают окна с итогом, объяснением метрики,
+разбивкой по странам и примерами событий. Счётчики стран считаются сервером
+по всей доступной истории за 24 часа с текущими фильтрами. Начиная с v0.25.0
+история загружается целиком по страницам, без ограничения последними 100 событиями. Открытое
+окно фиксирует данные на момент открытия; временная отметка показана внутри.
+Сетевые потоки остаются отдельным текущим снимком, не суточной статистикой.
+
+## Карта и полная история (v0.25.0)
+
+Карта использует векторные границы стран: при зуме 100–600% они перерисовываются,
+а маркеры и подписи сохраняют размер. Это обзорная карта стран, не уличная карта.
+Карточки и окна стран загружают всю сохранённую историю за последние 24 часа
+по 50 записей; фильтры учитываются сервером. В карточке IP показаны все уникальные
+HTTP IP с количеством запросов. Переходы между страницами фиксируют снимок истории.
+
+Для городов откройте настройки карты и нажмите «Установить базу городов».
+Dashboard скачает DB-IP City Lite 2026-10 (~58 МБ сжатая, ~121 МБ на диске),
+проверит контрольную сумму и сохранит `dbip-city.mmdb` рядом с `DASHBOARD_DB_PATH`.
+IP посетителей не отправляются во внешние сервисы. Город и регион отображаются
+в истории и списке IP; местоположение приблизительное и может относиться к VPN
+или провайдеру. Для части IP город неизвестен. База устанавливается отдельно от
+релиза, автоматически каждый месяц не обновляется.
+
+## Фильтр истории и зеркало GeoIP (v0.25.1)
+
+В окнах стран и событий есть локальный переключатель «Все события / HTTP /
+Срабатывания / Решения CrowdSec». Он меняет тип событий только внутри окна,
+сохраняя страну, домен, остальные фильтры и снимок времени; пагинация начинается
+с первой страницы. Сводные карточки над историей сохраняют исходные итоги.
+
+DB-IP City Lite загружается сначала из вложения релиза v0.25.1 в Gitea,
+при ошибке — с официального сервера DB-IP. Для собственного адреса Gitea можно
+задать `GITEA_URL` в окружении сервиса Dashboard. База хранится отдельно от Git-истории
+и бинарника приложения; контрольная сумма проверяется независимо от источника.
+Официальный файл: https://download.db-ip.com/free/dbip-city-lite-2026-10.mmdb.gz
+
+## Города на карте (v0.26.0)
+
+При установленной базе городов и масштабе от 200% на карте появляются города
+с HTTP/CrowdSec-активностью. Маркеры используют приблизительные координаты DB-IP,
+подписи не увеличиваются вместе с картой. Наведение показывает статистику,
+нажатие открывает карточку города с итогами и ссылкой на всю историю страны.
+HTTP/CrowdSec-импульсы также начинаются в городе, если он определён.
+
+Счётчики городов учитывают выбранного агента и фильтры за 24 часа. На карте
+показываются до 500 наиболее активных городов; остальные события и IP без города
+остаются в точках стран. TCP/UDP/ICMP пока отображаются на уровне стран.
+Город может относиться к провайдеру/VPN, а не фактическому местоположению человека.
--- a/agent_installer_test.go
+++ b/agent_installer_test.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Run the real installer in a temporary tree with package/service/download
+// commands stubbed. This must never touch the host's init system or packages.
+func TestAgentInstallerOpenRC(t *testing.T) {
+	for _, init := range []string{"openrc", "systemd"} {
+		t.Run(init, func(t *testing.T) {
+			root := t.TempDir()
+			bin := filepath.Join(root, "bin")
+			os.MkdirAll(bin, 0755)
+			write := func(name, body string) {
+				t.Helper()
+				if err := os.WriteFile(filepath.Join(bin, name), []byte("#!/bin/sh\nset -eu\n"+body), 0755); err != nil {
+					t.Fatal(err)
+				}
+			}
+			write("id", "echo 0\n")
+			write("uname", "echo x86_64\n")
+			hash := strings.Repeat("a", 64)
+			write("curl", `case "$1" in -fsSL) ;; *) exit 4 ;; esac
+if [ "$#" = 2 ]; then printf '%s' '{"browser_download_url":"https://example.test/proxmox-dashboard-linux-amd64"}'; exit; fi
+case "$2" in *.sha256) printf '%s\n' '`+hash+`  proxmox-dashboard-linux-amd64' > "$4" ;; *) printf '#!/bin/sh\nprintf "%%s\\n" "$@" > "$CAPTURE"\n' > "$4" ;; esac
+`)
+			write("sha256sum", "printf '%s\\n' '"+hash+"  binary'\n")
+			for _, name := range []string{"systemctl", "rc-service", "rc-update", "supervise-daemon"} {
+				write(name, `printf '%s %s\n' "$(basename "$0")" "$*" >> "$CALLS"`+"\n")
+			}
+			raw, err := os.ReadFile("scripts/install-agent.sh")
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Redirect every persistent absolute path, including those in generated scripts.
+			s := string(raw)
+			for _, prefix := range []string{"/etc/", "/var/lib/", "/usr/local/", "/run/", "/var/log/"} {
+				s = strings.ReplaceAll(s, prefix, root+prefix)
+			}
+			for _, dir := range []string{"etc/systemd/system", "etc/init.d", "var/log"} {
+				os.MkdirAll(filepath.Join(root, dir), 0755)
+			}
+			if init == "systemd" {
+				os.MkdirAll(filepath.Join(root, "run/systemd/system"), 0755)
+			}
+			script := filepath.Join(root, "install.sh")
+			os.WriteFile(script, []byte(s), 0700)
+			env := append(os.Environ(), "PATH="+bin+":"+os.Getenv("PATH"), "DASHBOARD_URL=https://dashboard.test", "ENROLL_TOKEN=token", "AGENT_NAME=Alpine $(touch should-not-exist)", "VMID=102", "CALLS="+root+"/calls", "CAPTURE="+root+"/args")
+			cmd := exec.Command("sh", script)
+			cmd.Env = env
+			if out, err := cmd.CombinedOutput(); err != nil {
+				t.Fatalf("%v: %s", err, out)
+			}
+			calls, _ := os.ReadFile(root + "/calls")
+			if init == "openrc" {
+				if strings.Contains(string(calls), "systemctl") || !strings.Contains(string(calls), "rc-update add proxmox-dashboard-agent default") || !strings.Contains(string(calls), "rc-service proxmox-dashboard-agent restart") {
+					t.Fatalf("%s", calls)
+				}
+				cmd = exec.Command("sh", root+"/usr/local/sbin/proxmox-dashboard-agent-run")
+				cmd.Env = env
+				if out, err := cmd.CombinedOutput(); err != nil {
+					t.Fatalf("launcher: %v %s", err, out)
+				}
+				args, _ := os.ReadFile(root + "/args")
+				if !strings.Contains(string(args), "Alpine $(touch should-not-exist)\n") {
+					t.Fatalf("name was not passed literally: %s", args)
+				}
+			} else if !strings.Contains(string(calls), "systemctl restart proxmox-dashboard-agent.service") {
+				t.Fatalf("%s", calls)
+			}
+			info, _ := os.Stat(root + "/etc/proxmox-dashboard-agent.env")
+			if info.Mode().Perm() != 0600 {
+				t.Fatalf("credentials permissions: %v", info.Mode())
+			}
+		})
+	}
+}
--- a/agent_network_setup.go
+++ b/agent_network_setup.go
@@ -60,6 +60,16 @@ func installNetworkDependency() error {
 	if os.Geteuid() != 0 {
 		return fmt.Errorf("для автоустановки нужны права root")
 	}
+	if apk, err := exec.LookPath("apk"); err == nil {
+		out := runAgentCombinedCommand(10*time.Minute, apk, "add", "--no-cache", "conntrack-tools")
+		if strings.HasPrefix(out, "ERROR: ") {
+			return fmt.Errorf("%s", out)
+		}
+		if _, err := exec.LookPath("conntrack"); err != nil {
+			return fmt.Errorf("apk завершился, но conntrack не найден")
+		}
+		return nil
+	}
 	apt, err := exec.LookPath("apt-get")
 	if err != nil {
 		return fmt.Errorf("автоустановка поддерживается на Debian/Ubuntu с apt-get; установите conntrack вручную")
--- a/agent_traffic.go
+++ b/agent_traffic.go
@@ -26,7 +26,7 @@ var npmTrafficPattern = regexp.MustCompile(`^\[([^]]+)\] .*? (\d{3}) - ([A-Z]+)
 func parseNPMTraffic(line string) (TrafficEvent, bool) {
 	m := npmTrafficPattern.FindStringSubmatch(line)
 	if m == nil {
-		return TrafficEvent{}, false
+		return parseNPMPlusTraffic(line)
 	}
 	ip := net.ParseIP(m[6])
 	if ip == nil {
@@ -55,11 +55,23 @@ type trafficAgentState struct {
 	CrowdSeen    map[string]int64         `json:"crowdSeen"`
 }

-func (state *trafficAgentState) readLogs(dir string) (int, error) {
+func (state *trafficAgentState) readLogs(dirs ...string) (int, error) {
 	state.BacklogBytes = 0
-	paths, err := filepath.Glob(filepath.Join(dir, "*_access.log*"))
-	if err != nil {
-		return 0, err
+	var paths []string
+	seenPaths := map[string]bool{}
+	for _, dir := range dirs {
+		for _, pattern := range []string{"*_access.log*", "access.log*"} {
+			matches, err := filepath.Glob(filepath.Join(dir, pattern))
+			if err != nil {
+				return 0, err
+			}
+			for _, path := range matches {
+				if !seenPaths[path] {
+					paths = append(paths, path)
+					seenPaths[path] = true
+				}
+			}
+		}
 	}
 	sort.Strings(paths)
 	files := 0
@@ -85,7 +97,7 @@ func (state *trafficAgentState) readLogs(dir string) (int, error) {
 			f.Close()
 			continue
 		}
-		active := strings.HasSuffix(path, "_access.log")
+		active := strings.HasSuffix(path, "_access.log") || filepath.Base(path) == "access.log"
 		if active {
 			files++
 		}
@@ -229,21 +241,31 @@ func parseCrowdTraffic(data []byte) ([]TrafficEvent, error) {

 // cscli uses the existing local machine credentials. No new bouncer key or
 // public LAPI port is needed, and only the read-only alerts list is executed.
-func collectCrowdTraffic(ctx context.Context) ([]TrafficEvent, bool, error) {
+func collectCrowdTraffic(ctx context.Context, container ...string) ([]TrafficEvent, bool, error) {
 	ctx, cancel := context.WithTimeout(ctx, 6*time.Second)
 	defer cancel()
-	cmd := exec.CommandContext(ctx, "cscli", "alerts", "list", "--since", "24h", "--limit", "50", "-o", "json")
-	var output limitedTrafficOutput
-	cmd.Stdout = &output
-	if err := cmd.Run(); err != nil {
-		return nil, false, errors.New("cscli alerts list недоступен; проверьте права агента и локальную LAPI")
+	var data []byte
+	if len(container) > 0 && container[0] != "" {
+		var err error
+		data, err = dockerCrowdOutput(ctx, container[0])
+		if err != nil {
+			return nil, false, errors.New("CrowdSec в Docker недоступен; проверьте контейнер и Docker socket")
+		}
+	} else {
+		cmd := exec.CommandContext(ctx, "cscli", "alerts", "list", "--since", "24h", "--limit", "50", "-o", "json")
+		var output limitedTrafficOutput
+		cmd.Stdout = &output
+		if err := cmd.Run(); err != nil {
+			return nil, false, errors.New("cscli недоступен на хосте; контейнер CrowdSec не обнаружен")
+		}
+		data = output.Bytes()
 	}
-	events, err := parseCrowdTraffic(output.Bytes())
+	events, err := parseCrowdTraffic(data)
 	if err != nil {
 		return nil, false, errors.New("Не удалось разобрать JSON CrowdSec")
 	}
 	var raw []json.RawMessage
-	json.Unmarshal(output.Bytes(), &raw)
+	json.Unmarshal(data, &raw)
 	return events, len(raw) >= 50, nil
 }

@@ -287,9 +309,6 @@ func runAgentTraffic(ctx context.Context, config agentConfig, stateDir string) {
 	if dir == "off" {
 		return
 	}
-	if dir == "" {
-		dir = "/opt/npm/data/logs"
-	}

 	statePath := filepath.Join(stateDir, "traffic-state.json")
 	state := trafficAgentState{StartedAt: time.Now().Unix(), Cursors: map[string]trafficCursor{}, CrowdSeen: map[string]int64{}}
@@ -310,6 +329,8 @@ func runAgentTraffic(ctx context.Context, config agentConfig, stateDir string) {
 	}
 	client := &http.Client{Timeout: 10 * time.Second}
 	lastCrowd := time.Time{}
+	lastDiscovery := time.Time{}
+	discovery := trafficDiscovery{}
 	crowdAt := int64(0)
 	crowdError := ""
 	crowdLimited := false
@@ -321,9 +342,21 @@ func runAgentTraffic(ctx context.Context, config agentConfig, stateDir string) {
 			return
 		default:
 		}
-		files, logErr := state.readLogs(dir)
+		if time.Since(lastDiscovery) >= time.Minute {
+			discovery = discoverTraffic(ctx)
+			lastDiscovery = time.Now()
+		}
+		files, logErr := state.readLogs(discovery.Dirs...)
+		if logErr != nil {
+			logErr = fmt.Errorf("%s; проверьте access-логи и LOGROTATE=true у NPM+", logErr)
+		}
 		if len(state.Pending) < 400 && time.Since(lastCrowd) >= 15*time.Second {
-			events, limited, err := collectCrowdTraffic(ctx)
+			events, limited, err := collectCrowdTraffic(ctx, discovery.CrowdContainer)
+			if discovery.Error != "" {
+				if _, localErr := exec.LookPath("cscli"); localErr != nil {
+					err = errors.New(discovery.Error)
+				}
+			}
 			crowdLimited = limited
 			lastCrowd = time.Now()
 			if err != nil {
--- a/agent_traffic_discovery.go
+++ b/agent_traffic_discovery.go
@@ -0,0 +1,209 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type trafficDockerContainer struct {
+	ID     string `json:"Id"`
+	Image  string
+	Names  []string
+	Mounts []struct{ Source, Destination string }
+}
+type trafficDiscovery struct {
+	Dirs           []string
+	CrowdContainer string
+	Error          string
+}
+
+func trafficDockerClient() *http.Client {
+	return &http.Client{Timeout: 8 * time.Second, Transport: &http.Transport{DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+		return (&net.Dialer{}).DialContext(ctx, "unix", "/var/run/docker.sock")
+	}}}
+}
+func discoverTraffic(ctx context.Context) trafficDiscovery {
+	d := trafficDiscovery{Dirs: []string{"/opt/npm/data/logs", "/opt/npmplus/nginx/logs", "/opt/npmplus/nginx"}}
+	client := trafficDockerClient()
+	defer client.CloseIdleConnections()
+	req, _ := http.NewRequestWithContext(ctx, "GET", "http://docker/containers/json", nil)
+	res, err := client.Do(req)
+	if err == nil {
+		defer res.Body.Close()
+		var containers []trafficDockerContainer
+		if res.StatusCode == 200 && json.NewDecoder(io.LimitReader(res.Body, 2<<20)).Decode(&containers) == nil {
+			d = trafficSources(containers, d.Dirs)
+		} else {
+			d.Error = "Не удалось прочитать список Docker-контейнеров"
+		}
+	} else if _, e := os.Stat("/var/run/docker.sock"); e == nil {
+		d.Error = "Docker socket недоступен агенту"
+	}
+	if dir := os.Getenv("DASHBOARD_NPM_LOG_DIR"); dir != "" {
+		d.Dirs = []string{dir}
+	}
+	if container := os.Getenv("DASHBOARD_CROWDSEC_CONTAINER"); container != "" {
+		d.CrowdContainer = container
+		d.Error = ""
+	}
+	return d
+}
+func trafficSources(containers []trafficDockerContainer, defaults []string) trafficDiscovery {
+	d := trafficDiscovery{Dirs: append([]string{}, defaults...)}
+	var crowd []string
+	for _, c := range containers {
+		img := strings.ToLower(c.Image)
+		if strings.Contains(img, "crowdsecurity/crowdsec:") || strings.HasSuffix(img, "crowdsecurity/crowdsec") || strings.Contains(img, "crowdsecurity/crowdsec@") {
+			crowd = append(crowd, c.ID)
+		}
+		if !strings.Contains(img, "nginx-proxy-manager") && !strings.Contains(img, "npmplus") {
+			continue
+		}
+		for _, target := range []string{"/data/logs", "/data/nginx/logs", "/data/nginx"} {
+			// Use the most specific mount, including a nested bind or named volume.
+			best, source := "", ""
+			for _, m := range c.Mounts {
+				dst := filepath.Clean(m.Destination)
+				if filepath.IsAbs(m.Source) && (target == dst || strings.HasPrefix(target, dst+"/")) && len(dst) > len(best) {
+					best = dst
+					source = filepath.Join(m.Source, strings.TrimPrefix(target, dst))
+				}
+			}
+			if source != "" {
+				d.Dirs = append(d.Dirs, source)
+			}
+		}
+	}
+	if len(crowd) == 1 {
+		d.CrowdContainer = crowd[0]
+	} else if len(crowd) > 1 {
+		d.Error = "Найдено несколько CrowdSec: задайте DASHBOARD_CROWDSEC_CONTAINER"
+	}
+	unique := map[string]bool{}
+	dirs := []string{}
+	for _, dir := range d.Dirs {
+		dir = filepath.Clean(dir)
+		if !unique[dir] {
+			unique[dir] = true
+			dirs = append(dirs, dir)
+		}
+	}
+	d.Dirs = dirs
+	return d
+}
+
+// Docker exec uses a fixed read-only command; no shell, credential extraction or published LAPI.
+func dockerCrowdOutput(ctx context.Context, container string) ([]byte, error) {
+	client := trafficDockerClient()
+	defer client.CloseIdleConnections()
+	return dockerCrowdWithClient(ctx, container, client)
+}
+func dockerCrowdWithClient(ctx context.Context, container string, client *http.Client) ([]byte, error) {
+	if !safeContainerName.MatchString(container) || strings.HasPrefix(container, "-") {
+		return nil, fmt.Errorf("некорректный контейнер CrowdSec")
+	}
+	call := func(path string, payload any) (*http.Response, error) {
+		raw, _ := json.Marshal(payload)
+		req, _ := http.NewRequestWithContext(ctx, "POST", "http://docker"+path, bytes.NewReader(raw))
+		req.Header.Set("Content-Type", "application/json")
+		return client.Do(req)
+	}
+	res, err := call("/containers/"+container+"/exec", map[string]any{"AttachStdout": true, "AttachStderr": true, "Tty": false, "Cmd": []string{"cscli", "alerts", "list", "--since", "24h", "--limit", "50", "-o", "json"}})
+	if err != nil {
+		return nil, err
+	}
+	var created struct{ ID string }
+	err = json.NewDecoder(io.LimitReader(res.Body, 4096)).Decode(&created)
+	res.Body.Close()
+	if err != nil || res.StatusCode != 201 || !safeContainerName.MatchString(created.ID) {
+		return nil, fmt.Errorf("Docker не создал cscli exec")
+	}
+	res, err = call("/exec/"+created.ID+"/start", map[string]any{"Detach": false, "Tty": false})
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != 200 {
+		return nil, fmt.Errorf("Docker cscli exec: %s", res.Status)
+	}
+	output, err := readDockerTrafficOutput(res.Body)
+	if err != nil {
+		return nil, err
+	}
+	req, _ := http.NewRequestWithContext(ctx, "GET", "http://docker/exec/"+created.ID+"/json", nil)
+	check, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer check.Body.Close()
+	var status struct {
+		Running  bool
+		ExitCode int
+	}
+	if check.StatusCode != 200 || json.NewDecoder(io.LimitReader(check.Body, 4096)).Decode(&status) != nil || status.Running || status.ExitCode != 0 {
+		return nil, fmt.Errorf("cscli внутри Docker завершился с ошибкой")
+	}
+	return output, nil
+}
+func readDockerTrafficOutput(r io.Reader) ([]byte, error) {
+	var out bytes.Buffer
+	total := uint32(0)
+	for {
+		var header [8]byte
+		_, err := io.ReadFull(r, header[:])
+		if err == io.EOF {
+			return out.Bytes(), nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		n := binary.BigEndian.Uint32(header[4:])
+		if n > 4<<20 || total+n > 4<<20 {
+			return nil, fmt.Errorf("Docker output too large")
+		}
+		total += n
+		if header[0] != 1 && header[0] != 2 {
+			return nil, fmt.Errorf("invalid Docker stream")
+		}
+		if header[0] == 1 {
+			_, err = io.CopyN(&out, r, int64(n))
+		} else {
+			_, err = io.CopyN(io.Discard, r, int64(n))
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+}
+
+var npmPlusTrafficPattern = regexp.MustCompile(`^\[([^]]+)\] (\S+) (\S+) [0-9.]+ "([A-Z]+) ([^" ]+) HTTP/[0-9.]+" (\d{3}) `)
+
+func parseNPMPlusTraffic(line string) (TrafficEvent, bool) {
+	m := npmPlusTrafficPattern.FindStringSubmatch(line)
+	if m == nil {
+		return TrafficEvent{}, false
+	}
+	ip := net.ParseIP(m[3])
+	ts, err := time.Parse("02/Jan/2006:15:04:05 -0700", m[1])
+	if ip == nil || err != nil {
+		return TrafficEvent{}, false
+	}
+	host := m[2]
+	if h, _, err := net.SplitHostPort(host); err == nil {
+		host = h
+	}
+	status, _ := strconv.Atoi(m[6])
+	return TrafficEvent{Time: ts.Unix(), Kind: "request", IP: ip.String(), Domain: trafficText(host, 253), Method: m[4], Path: trafficPath(m[5]), Status: status}, true
+}
--- a/agent_traffic_discovery_test.go
+++ b/agent_traffic_discovery_test.go
@@ -0,0 +1,134 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestNPMPlusTraffic(t *testing.T) {
+	for _, ip := range []string{"8.8.8.8", "2001:4860:4860::8888"} {
+		line := `[14/Oct/2026:16:24:17 +0000] example.test:8443 ` + ip + ` 0.001 "GET /health?token=secret HTTP/3.0" 200 123 "-" "test" "-" "text/html" TLSv1.3 - - -`
+		e, ok := parseNPMTraffic(line)
+		if !ok || e.IP != ip || e.Domain != "example.test" || e.Path != "/health" || e.Status != 200 {
+			t.Fatalf("%+v %v", e, ok)
+		}
+	}
+	if _, ok := parseNPMTraffic(`[14/Oct/2026:16:24:17 +0000] 443 8.8.8.8 UDP - 200 10 20 0.001`); ok {
+		t.Fatal("stream counted as HTTP")
+	}
+}
+func TestDockerTrafficDiscovery(t *testing.T) {
+	var containers []trafficDockerContainer
+	json.Unmarshal([]byte(`[{"Id":"aaa","Image":"ghcr.io/zoeyvid/npmplus:latest","Mounts":[{"Source":"/var/lib/docker/volumes/npm/_data","Destination":"/data"},{"Source":"/srv/logs","Destination":"/data/nginx/logs"}]},{"Id":"bbb","Image":"crowdsecurity/crowdsec:latest"}]`), &containers)
+	d := trafficSources(containers, nil)
+	if d.CrowdContainer != "bbb" || d.Error != "" || strings.Join(d.Dirs, ",") != "/var/lib/docker/volumes/npm/_data/logs,/srv/logs,/var/lib/docker/volumes/npm/_data/nginx" {
+		t.Fatalf("%+v", d)
+	}
+	containers = append(containers, containers[1])
+	d = trafficSources(containers, nil)
+	if d.CrowdContainer != "" || d.Error == "" {
+		t.Fatal("ambiguous CrowdSec silently chosen")
+	}
+}
+func TestDockerTrafficDemux(t *testing.T) {
+	var b bytes.Buffer
+	for _, frame := range []struct {
+		stream byte
+		text   string
+	}{{2, "diagnostic"}, {1, "["}, {1, "]"}} {
+		h := []byte{frame.stream, 0, 0, 0, 0, 0, 0, 0}
+		binary.BigEndian.PutUint32(h[4:], uint32(len(frame.text)))
+		b.Write(h)
+		b.WriteString(frame.text)
+	}
+	out, err := readDockerTrafficOutput(&b)
+	if err != nil || string(out) != "[]" {
+		t.Fatalf("%q %v", out, err)
+	}
+	if _, err := readDockerTrafficOutput(bytes.NewReader([]byte{1, 0, 0})); err == nil {
+		t.Fatal("truncation accepted")
+	}
+	if _, err := readDockerTrafficOutput(bytes.NewReader([]byte{1, 0, 0, 0, 255, 255, 255, 255})); err == nil {
+		t.Fatal("oversized frame accepted")
+	}
+}
+func TestTrafficMultipleDirectoriesAndNPMPlusRotation(t *testing.T) {
+	a, b := t.TempDir(), t.TempDir()
+	p := filepath.Join(b, "access.log")
+	os.WriteFile(filepath.Join(a, "proxy-host-1_access.log"), nil, 0600)
+	os.WriteFile(p, nil, 0600)
+	s := trafficAgentState{Cursors: map[string]trafficCursor{}}
+	if n, err := s.readLogs(a, b, a); err != nil || n != 2 {
+		t.Fatalf("files %d: %v", n, err)
+	}
+	line := "[" + time.Now().UTC().Format("02/Jan/2006:15:04:05 -0700") + `] example.test 8.8.8.8 0.1 "GET / HTTP/2.0" 200 123 "-"` + "\n"
+	os.WriteFile(p, []byte(line), 0600)
+	s.readLogs(a, b)
+	if len(s.Pending) != 1 {
+		t.Fatal("NPM+ event missing")
+	}
+	s.Pending = nil
+	os.Rename(p, p+".1")
+	os.WriteFile(p, []byte(line), 0600)
+	s.readLogs(a, b)
+	if len(s.Pending) != 1 {
+		t.Fatalf("rotation duplicated/lost events: %d", len(s.Pending))
+	}
+}
+
+type trafficRoundTrip func(*http.Request) (*http.Response, error)
+
+func (f trafficRoundTrip) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
+func TestDockerCrowdExec(t *testing.T) {
+	for _, exitCode := range []int{0, 1} {
+		calls := 0
+		client := &http.Client{Transport: trafficRoundTrip(func(r *http.Request) (*http.Response, error) {
+			calls++
+			body := ""
+			status := 200
+			switch calls {
+			case 1:
+				if r.Method != "POST" || r.URL.Path != "/containers/crowdsec/exec" {
+					t.Fatalf("unexpected %s %s", r.Method, r.URL)
+				}
+				var payload struct {
+					Cmd []string
+					Tty bool
+				}
+				json.NewDecoder(r.Body).Decode(&payload)
+				if strings.Join(payload.Cmd, " ") != "cscli alerts list --since 24h --limit 50 -o json" || payload.Tty {
+					t.Fatalf("unexpected command %+v", payload)
+				}
+				status = 201
+				body = `{"Id":"exec123"}`
+			case 2:
+				if r.URL.Path != "/exec/exec123/start" {
+					t.Fatal(r.URL)
+				}
+				body = string([]byte{1, 0, 0, 0, 0, 0, 0, 2}) + "[]"
+			case 3:
+				if r.Method != "GET" || r.URL.Path != "/exec/exec123/json" {
+					t.Fatal(r.URL)
+				}
+				body = fmt.Sprintf(`{"Running":false,"ExitCode":%d}`, exitCode)
+			default:
+				t.Fatal("extra Docker request")
+			}
+			return &http.Response{StatusCode: status, Body: io.NopCloser(strings.NewReader(body)), Header: make(http.Header)}, nil
+		})}
+		out, err := dockerCrowdWithClient(context.Background(), "crowdsec", client)
+		if calls != 3 || (exitCode == 0 && (err != nil || string(out) != "[]")) || (exitCode != 0 && err == nil) {
+			t.Fatalf("calls=%d output=%s err=%v", calls, out, err)
+		}
+	}
+}
--- a/assets/NOTICE.md
+++ b/assets/NOTICE.md
@@ -12,3 +12,9 @@ https://creativecommons.org/licenses/by/4.0/
 https://db-ip.com/db/download/ip-to-country-lite
 The database is unmodified. The traffic page displays the required DB-IP link.
 Countries are approximate; plotted positions are country labels, not exact IP locations.
+
+Optional DB-IP City Lite October 2026 is downloaded separately through Settings.
+Source: https://download.db-ip.com/free/dbip-city-lite-2026-10.mmdb.gz
+License: CC BY 4.0, https://creativecommons.org/licenses/by/4.0/
+https://db-ip.com/db/download/ip-to-city-lite
+The database is unmodified; city and region are approximate.
--- a/assets/traffic.html
+++ b/assets/traffic.html
--- a/scripts/install-agent.sh
+++ b/scripts/install-agent.sh
@@ -10,11 +10,28 @@ if [ -z "${DASHBOARD_URL:-}" ] || [ -z "${ENROLL_TOKEN:-}" ]; then
  exit 1
 fi

+case "$(uname -m)" in x86_64|amd64) ;; *) echo "Поддерживается Linux amd64 (x86_64)." >&2; exit 1 ;; esac
+if command -v systemctl >/dev/null 2>&1 && [ -d /run/systemd/system ]; then
+  agent_init=systemd
+elif command -v rc-service >/dev/null 2>&1 && command -v supervise-daemon >/dev/null 2>&1; then
+  agent_init=openrc
+else
+  echo "Нужен работающий systemd или OpenRC с supervise-daemon." >&2; exit 1
+fi
+if ! command -v curl >/dev/null 2>&1; then
+  if command -v apk >/dev/null 2>&1; then apk add --no-cache curl ca-certificates; else echo "Установите curl и ca-certificates." >&2; exit 1; fi
+fi
+
 GITEA_URL=${GITEA_URL:-https://git.myown.center}
 GITEA_REPOSITORY=${GITEA_REPOSITORY:-maxim/ProxmoxDash}
 VMID=${VMID:-0}
 AGENT_NAME=${AGENT_NAME:-$(hostname)}

+case "$DASHBOARD_URL$ENROLL_TOKEN$AGENT_NAME$VMID" in
+  *'
+'*) echo "Параметры установки не должны содержать переносы строк." >&2; exit 1 ;;
+esac
+
 release_json=$(curl -fsSL "$GITEA_URL/api/v1/repos/$GITEA_REPOSITORY/releases/latest")
 download_url=$(printf '%s' "$release_json" | sed -n 's/.*"browser_download_url":"\([^"]*\/proxmox-dashboard-linux-amd64\)".*/\1/p' | head -n 1)
 if [ -z "$download_url" ]; then
@@ -24,8 +41,12 @@ fi

 install -d -m 0700 /var/lib/proxmox-dashboard-agent
 temporary_binary=$(mktemp /tmp/proxmox-dashboard-agent.XXXXXX)
-trap 'rm -f "$temporary_binary"' EXIT
+trap 'rm -f "$temporary_binary" "$temporary_binary.sha256"' EXIT
 curl -fsSL "$download_url" -o "$temporary_binary"
+curl -fsSL "$download_url.sha256" -o "$temporary_binary.sha256"
+expected_hash=$(awk 'NR==1 {print $1}' "$temporary_binary.sha256")
+actual_hash=$(sha256sum "$temporary_binary" | awk '{print $1}')
+if [ "${#expected_hash}" -ne 64 ] || [ "$expected_hash" != "$actual_hash" ]; then echo "SHA-256 загрузки не совпал." >&2; exit 1; fi
 install -m 0755 "$temporary_binary" /var/lib/proxmox-dashboard-agent/proxmox-dashboard-agent

 umask 077
@@ -36,6 +57,7 @@ umask 077
  printf 'VMID=%s\n' "$VMID"
 } > /etc/proxmox-dashboard-agent.env

+if [ "$agent_init" = systemd ]; then
 cat > /etc/systemd/system/proxmox-dashboard-agent.service <<'UNIT'
 [Unit]
 Description=Proxmox Dashboard read-only guest agent
@@ -61,5 +83,38 @@ UNIT
 systemctl daemon-reload
 systemctl enable proxmox-dashboard-agent.service
 systemctl restart proxmox-dashboard-agent.service
+else
+  mkdir -p /usr/local/sbin /etc/init.d
+  cat > /usr/local/sbin/proxmox-dashboard-agent-run <<'RUN'
+#!/bin/sh
+set -eu
+# Parse literal key=value records, never evaluate configuration as shell code.
+while IFS='=' read -r key value; do
+  case "$key" in DASHBOARD_URL|ENROLL_TOKEN|AGENT_NAME|VMID|DASHBOARD_NPM_LOG_DIR|DASHBOARD_CROWDSEC_CONTAINER) export "$key=$value" ;; esac
+done < /etc/proxmox-dashboard-agent.env
+exec /var/lib/proxmox-dashboard-agent/proxmox-dashboard-agent --agent --agent-server "$DASHBOARD_URL" --agent-enroll-token "$ENROLL_TOKEN" --agent-name "$AGENT_NAME" --agent-vmid "$VMID"
+RUN
+  chmod 0755 /usr/local/sbin/proxmox-dashboard-agent-run
+  cat > /etc/init.d/proxmox-dashboard-agent <<'OPENRC'
+#!/sbin/openrc-run
+description="Proxmox Dashboard guest agent"
+command="/usr/local/sbin/proxmox-dashboard-agent-run"
+supervisor="supervise-daemon"
+respawn_delay=5
+respawn_max=0
+output_log="/var/log/proxmox-dashboard-agent.log"
+error_log="/var/log/proxmox-dashboard-agent.log"
+depend() {
+  need net
+  after docker
+}
+start_pre() {
+  checkpath --file --mode 0600 /var/log/proxmox-dashboard-agent.log
+}
+OPENRC
+  chmod 0755 /etc/init.d/proxmox-dashboard-agent
+  rc-update add proxmox-dashboard-agent default
+  rc-service proxmox-dashboard-agent restart
+fi
 rm -f /usr/local/bin/proxmox-dashboard-agent
 echo "Агент установлен. Через несколько секунд он появится в Dashboard."
--- a/scripts/uninstall-agent.sh
+++ b/scripts/uninstall-agent.sh
@@ -6,11 +6,16 @@ if [ "$(id -u)" -ne 0 ]; then
  exit 1
 fi

+if command -v rc-service >/dev/null 2>&1 && [ -f /etc/init.d/proxmox-dashboard-agent ]; then
+  rc-service proxmox-dashboard-agent stop || true
+  rc-update del proxmox-dashboard-agent default || true
+fi
 systemctl disable --now proxmox-dashboard-agent.service 2>/dev/null || true
+rm -f /etc/init.d/proxmox-dashboard-agent /usr/local/sbin/proxmox-dashboard-agent-run
 rm -f /etc/systemd/system/proxmox-dashboard-agent.service
 rm -f /etc/proxmox-dashboard-agent.env
 rm -f /usr/local/bin/proxmox-dashboard-agent
 rm -rf /var/lib/proxmox-dashboard-agent
-systemctl daemon-reload
+systemctl daemon-reload 2>/dev/null || true
 systemctl reset-failed proxmox-dashboard-agent.service 2>/dev/null || true
 echo "Агент и его локальные учётные данные удалены."
--- a/traffic.go
+++ b/traffic.go
@@ -12,19 +12,22 @@ import (
 )

 type TrafficEvent struct {
-	Monitoring bool   `json:"monitoring"`
-	ID         string `json:"id"`
-	Sequence   int64  `json:"sequence,omitempty"`
-	Time       int64  `json:"time"`
-	Kind       string `json:"kind"`
-	IP         string `json:"ip"`
-	Domain     string `json:"domain,omitempty"`
-	Method     string `json:"method,omitempty"`
-	Path       string `json:"path,omitempty"`
-	Status     int    `json:"status,omitempty"`
-	Reason     string `json:"reason,omitempty"`
-	Country    string `json:"country,omitempty"`
-	Agent      string `json:"agent,omitempty"`
+	Location   *TrafficCityLocation `json:"location,omitempty"`
+	City       string               `json:"city,omitempty"`
+	Region     string               `json:"region,omitempty"`
+	Monitoring bool                 `json:"monitoring"`
+	ID         string               `json:"id"`
+	Sequence   int64                `json:"sequence,omitempty"`
+	Time       int64                `json:"time"`
+	Kind       string               `json:"kind"`
+	IP         string               `json:"ip"`
+	Domain     string               `json:"domain,omitempty"`
+	Method     string               `json:"method,omitempty"`
+	Path       string               `json:"path,omitempty"`
+	Status     int                  `json:"status,omitempty"`
+	Reason     string               `json:"reason,omitempty"`
+	Country    string               `json:"country,omitempty"`
+	Agent      string               `json:"agent,omitempty"`
 }

 type TrafficBatch struct {
@@ -51,7 +54,21 @@ type TrafficCount struct {
 	Count int64  `json:"count"`
 }

+type TrafficCountryDetail struct {
+	Country   string `json:"country"`
+	Requests  int64  `json:"requests"`
+	UniqueIPs int64  `json:"uniqueIps"`
+	Alerts    int64  `json:"alerts"`
+	Decisions int64  `json:"decisions"`
+	LastSeen  int64  `json:"lastSeen"`
+}
 type TrafficView struct {
+	Cities         []TrafficMapCity       `json:"cities"`
+	CitiesLimited  bool                   `json:"citiesLimited"`
+	CityReady      bool                   `json:"cityReady"`
+	MaxSequence    int64                  `json:"maxSequence"`
+	CountryDetails []TrafficCountryDetail `json:"countryDetails"`
+
 	Network   *NetworkMapView `json:"network,omitempty"`
 	Events    []TrafficEvent  `json:"events"`
 	Sources   []TrafficSource `json:"sources"`
@@ -160,8 +177,11 @@ func (s *Store) TrafficView(domain, kind string, external bool, hideMonitoring .
 		network := makeNetworkMap(snapshot, external)
 		v.Network = &network
 	}
-	where := ` WHERE ts>=? AND agent=?`
-	args := []any{now - 86400, v.Settings.AgentID}
+	if err := s.db.QueryRow(`SELECT COALESCE(MAX(seq),0) FROM traffic_events WHERE agent=?`, v.Settings.AgentID).Scan(&v.MaxSequence); err != nil {
+		return v, err
+	}
+	where := ` WHERE ts>=? AND agent=? AND ts<=? AND seq<=?`
+	args := []any{now - 86400, v.Settings.AgentID, now, v.MaxSequence}
 	if hide {
 		clause, params := monitoringSQL(v.Settings.MonitoringRules)
 		where += clause
@@ -193,6 +213,11 @@ func (s *Store) TrafficView(domain, kind string, external bool, hideMonitoring .
 			return v, err
 		}
 		e.Monitoring = isMonitoringRequest(e, v.Settings.MonitoringRules)
+		g := lookupTrafficCityLocation(e.IP)
+		e.City, e.Region = g.City, g.Region
+		if g.Located {
+			e.Location = &g
+		}
 		v.Events = append(v.Events, e)
 	}
 	err = rows.Err()
@@ -222,6 +247,32 @@ func (s *Store) TrafficView(domain, kind string, external bool, hideMonitoring .
 			return v, e
 		}
 	}
+	detailRows, detailErr := s.db.Query(`SELECT country,SUM(kind='request'),COUNT(DISTINCT CASE WHEN kind='request' THEN ip END),SUM(kind='alert'),SUM(kind='decision'),MAX(ts) FROM traffic_events`+where+` GROUP BY country`, args...)
+	if detailErr != nil {
+		return v, detailErr
+	}
+	v.CountryDetails = []TrafficCountryDetail{}
+	for detailRows.Next() {
+		var d TrafficCountryDetail
+		if err = detailRows.Scan(&d.Country, &d.Requests, &d.UniqueIPs, &d.Alerts, &d.Decisions, &d.LastSeen); err != nil {
+			detailRows.Close()
+			return v, err
+		}
+		v.CountryDetails = append(v.CountryDetails, d)
+	}
+	detailErr = detailRows.Err()
+	detailRows.Close()
+	if detailErr != nil {
+		return v, detailErr
+	}
+	v.CityReady = trafficCityReady()
+	if v.CityReady {
+		var cityErr error
+		v.Cities, v.CitiesLimited, cityErr = s.trafficMapCities(where, args)
+		if cityErr != nil {
+			return v, cityErr
+		}
+	}
 	r, err := s.db.Query(`SELECT CAST((ts/60)*60 AS TEXT),COUNT(*) FROM traffic_events`+where+` AND kind='request' AND ts>=? GROUP BY ts/60 ORDER BY ts/60`, append(args, now-3600)...)
 	if err != nil {
 		return v, err
@@ -263,6 +314,8 @@ func (s *Store) TrafficView(domain, kind string, external bool, hideMonitoring .

 func trafficRoutes(mux *http.ServeMux, s *Store) {
 	trafficSettingsRoute(mux, s)
+	s.trafficHistoryRoute(mux)
+	trafficCityRoutes(mux)
 	networkRoutes(mux, s)
 	mux.HandleFunc("/traffic", func(w http.ResponseWriter, r *http.Request) {
 		if !s.TrafficSettings().Enabled {
--- a/traffic_city.go
+++ b/traffic_city.go
@@ -0,0 +1,216 @@
+package main
+
+import (
+	"compress/gzip"
+	"crypto/sha1"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"math"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/oschwald/maxminddb-golang"
+)
+
+const cityDownloadURL = "https://download.db-ip.com/free/dbip-city-lite-2026-10.mmdb.gz"
+const cityDatabaseSHA1 = "df17bd24390108ed1d24dcb7718dc60f6b9abd4f"
+
+var trafficCity struct {
+	sync.Mutex
+	once    sync.Once
+	db      *maxminddb.Reader
+	running bool
+	message string
+	cache   map[string]TrafficCityLocation
+}
+
+func trafficCityPath() string {
+	db := os.Getenv("DASHBOARD_DB_PATH")
+	if db == "" {
+		db = defaultDatabasePath
+	}
+	return filepath.Join(filepath.Dir(db), "dbip-city.mmdb")
+}
+func trafficCityReady() bool {
+	trafficCity.once.Do(func() {
+		trafficCity.Lock()
+		defer trafficCity.Unlock()
+		trafficCity.db, _ = maxminddb.Open(trafficCityPath())
+		if trafficCity.db != nil && !strings.Contains(strings.ToLower(trafficCity.db.Metadata.DatabaseType), "city") {
+			trafficCity.db.Close()
+			trafficCity.db = nil
+		}
+	})
+	trafficCity.Lock()
+	defer trafficCity.Unlock()
+	return trafficCity.db != nil
+}
+
+type TrafficCityLocation struct {
+	City      string  `json:"city"`
+	Region    string  `json:"region,omitempty"`
+	Latitude  float64 `json:"latitude"`
+	Longitude float64 `json:"longitude"`
+	Located   bool    `json:"located"`
+}
+
+func lookupTrafficCity(text string) (string, string) {
+	g := lookupTrafficCityLocation(text)
+	return g.City, g.Region
+}
+func lookupTrafficCityLocation(text string) TrafficCityLocation {
+	ip := net.ParseIP(text)
+	if ip == nil || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || !ip.IsGlobalUnicast() || !trafficCityReady() {
+		return TrafficCityLocation{}
+	}
+	trafficCity.Lock()
+	defer trafficCity.Unlock()
+	if g, ok := trafficCity.cache[text]; ok {
+		return g
+	}
+	var r struct {
+		Location struct {
+			Latitude  *float64 `maxminddb:"latitude"`
+			Longitude *float64 `maxminddb:"longitude"`
+		} `maxminddb:"location"`
+		City struct {
+			Names map[string]string `maxminddb:"names"`
+		} `maxminddb:"city"`
+		Subdivisions []struct {
+			Names map[string]string `maxminddb:"names"`
+		} `maxminddb:"subdivisions"`
+	}
+	if trafficCity.db.Lookup(ip, &r) != nil {
+		return TrafficCityLocation{}
+	}
+	region := ""
+	if len(r.Subdivisions) > 0 {
+		region = cityName(r.Subdivisions[0].Names)
+	}
+	g := TrafficCityLocation{City: cityName(r.City.Names), Region: region}
+	if g.City != "" && r.Location.Latitude != nil && r.Location.Longitude != nil {
+		g.Latitude, g.Longitude = *r.Location.Latitude, *r.Location.Longitude
+		g.Located = !math.IsNaN(g.Latitude) && !math.IsNaN(g.Longitude) && math.Abs(g.Latitude) <= 90 && math.Abs(g.Longitude) <= 180
+	}
+	if trafficCity.cache == nil {
+		trafficCity.cache = map[string]TrafficCityLocation{}
+	}
+	if len(trafficCity.cache) < 32768 {
+		trafficCity.cache[text] = g
+	}
+	return g
+}
+func trafficCityRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("/api/settings/traffic/city-database", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "GET" && r.Method != "POST" {
+			w.WriteHeader(405)
+			return
+		}
+		trafficCityReady()
+		trafficCity.Lock()
+		if r.Method == "POST" && !trafficCity.running && trafficCity.db == nil {
+			trafficCity.running = true
+			trafficCity.message = "Загрузка базы городов (около 58 МБ)…"
+			go func() {
+				err := installTrafficCity()
+				trafficCity.Lock()
+				defer trafficCity.Unlock()
+				trafficCity.running = false
+				if err != nil {
+					trafficCity.message = "Не удалось установить базу: " + err.Error()
+				} else {
+					trafficCity.message = "База городов DB-IP City Lite 2026-10 установлена"
+				}
+			}()
+		}
+		status := map[string]any{"ready": trafficCity.db != nil, "running": trafficCity.running, "message": trafficCity.message, "date": "2026-10"}
+		trafficCity.Unlock()
+		writeJSON(w, status, nil)
+	})
+}
+func cityMirrorURL() string {
+	base := strings.TrimRight(os.Getenv("GITEA_URL"), "/")
+	if base == "" {
+		base = "https://git.myown.center"
+	}
+	return base + "/maxim/ProxmoxDash/releases/download/v0.25.1/dbip-city-lite-2026-10.mmdb.gz"
+}
+func installTrafficCity() error {
+	if err := installTrafficCityFrom(cityMirrorURL(), cityDatabaseSHA1); err == nil {
+		return nil
+	}
+	return installTrafficCityFrom(cityDownloadURL, cityDatabaseSHA1)
+}
+func installTrafficCityFrom(source, expectedHash string) error {
+	transport := http.DefaultTransport.(*http.Transport).Clone()
+	transport.ResponseHeaderTimeout = 20 * time.Second
+	transport.DialContext = (&net.Dialer{Timeout: 10 * time.Second, KeepAlive: 30 * time.Second}).DialContext
+	defer transport.CloseIdleConnections()
+	client := &http.Client{Timeout: 15 * time.Minute, Transport: transport}
+	response, err := client.Get(source)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode != 200 {
+		return fmt.Errorf("HTTP %d", response.StatusCode)
+	}
+	reader, err := gzip.NewReader(io.LimitReader(response.Body, 70<<20))
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+	path := trafficCityPath()
+	if err = os.MkdirAll(filepath.Dir(path), 0750); err != nil {
+		return err
+	}
+	file, err := os.CreateTemp(filepath.Dir(path), ".city-*.mmdb")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(file.Name())
+	defer file.Close()
+	hash := sha1.New()
+	n, err := io.Copy(io.MultiWriter(file, hash), io.LimitReader(reader, (160<<20)+1))
+	if err != nil {
+		return err
+	}
+	if n > 160<<20 {
+		return fmt.Errorf("база превышает лимит размера")
+	}
+	if hex.EncodeToString(hash.Sum(nil)) != expectedHash {
+		return fmt.Errorf("контрольная сумма базы не совпала")
+	}
+	if err = file.Sync(); err != nil {
+		return err
+	}
+	if err = file.Close(); err != nil {
+		return err
+	}
+	db, err := maxminddb.Open(file.Name())
+	if err != nil {
+		return err
+	}
+	if !strings.Contains(strings.ToLower(db.Metadata.DatabaseType), "city") {
+		db.Close()
+		return fmt.Errorf("неверный тип GeoIP-базы")
+	}
+	if err = os.Rename(file.Name(), path); err != nil {
+		db.Close()
+		return err
+	}
+	trafficCity.Lock()
+	defer trafficCity.Unlock()
+	if trafficCity.db != nil {
+		trafficCity.db.Close()
+	}
+	trafficCity.db = db
+	trafficCity.cache = nil
+	return nil
+}
--- a/traffic_city_test.go
+++ b/traffic_city_test.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+	"compress/gzip"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestCityInstallRejectsBadDownload(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("DASHBOARD_DB_PATH", filepath.Join(dir, "dashboard.db"))
+	existing := []byte("existing database")
+	if err := os.WriteFile(trafficCityPath(), existing, 0600); err != nil {
+		t.Fatal(err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		g := gzip.NewWriter(w)
+		g.Write([]byte("corrupt database"))
+		g.Close()
+	}))
+	defer server.Close()
+	if err := installTrafficCityFrom(server.URL, cityDatabaseSHA1); err == nil {
+		t.Fatal("bad checksum accepted")
+	}
+	got, err := os.ReadFile(trafficCityPath())
+	if err != nil || string(got) != string(existing) {
+		t.Fatal("existing database replaced on failure")
+	}
+	files, _ := filepath.Glob(filepath.Join(dir, ".city-*"))
+	if len(files) != 0 {
+		t.Fatal("partial file left behind")
+	}
+}
+func TestCityDatabaseDownloaded(t *testing.T) {
+	source := os.Getenv("DASHBOARD_CITY_TEST_GZIP")
+	if source == "" {
+		t.Skip("optional official database integration test")
+	}
+	t.Setenv("DASHBOARD_DB_PATH", filepath.Join(t.TempDir(), "dashboard.db"))
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.ServeFile(w, r, source) }))
+	defer server.Close()
+	trafficCityReady()
+	if err := installTrafficCityFrom(server.URL, cityDatabaseSHA1); err != nil {
+		t.Fatal(err)
+	}
+	g := lookupTrafficCityLocation("20.194.96.114")
+	if !g.Located || g.Latitude < 30 || g.Latitude > 40 || g.Longitude < 120 || g.Longitude > 130 {
+		t.Fatalf("invalid Seoul coordinates: %+v", g)
+	}
+	s, a := trafficFixture(t)
+	s.SaveTrafficSettings(TrafficSettings{Enabled: true, AgentID: a.ID})
+	now := time.Now().Unix()
+	if err := s.SaveTraffic(a.ID, TrafficBatch{Events: []TrafficEvent{
+		{ID: "1", Time: now, Kind: "request", IP: "20.194.96.114", Domain: "a.test"},
+		{ID: "2", Time: now, Kind: "request", IP: "20.194.96.114", Domain: "a.test"},
+		{ID: "3", Time: now, Kind: "alert", IP: "20.194.96.114", Domain: "b.test"},
+		{ID: "4", Time: now, Kind: "request", IP: "192.168.0.10"},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+	view, err := s.TrafficView("", "", false)
+	if err != nil || len(view.Cities) != 1 {
+		t.Fatalf("cities %+v err %v", view.Cities, err)
+	}
+	c := view.Cities[0]
+	if c.Requests != 2 || c.UniqueIPs != 1 || c.Alerts != 1 || c.City != g.City {
+		t.Fatalf("bad aggregation %+v", c)
+	}
+	filtered, err := s.TrafficView("b.test", "alert", false)
+	if err != nil || len(filtered.Cities) != 1 || filtered.Cities[0].Requests != 0 || filtered.Cities[0].Alerts != 1 {
+		t.Fatalf("city filter %+v %v", filtered.Cities, err)
+	}
+	city, region := lookupTrafficCity("20.194.96.114")
+	t.Logf("city=%q region=%q", city, region)
+	if city == "" {
+		t.Fatal("public IP city not decoded")
+	}
+}
--- a/traffic_country_test.go
+++ b/traffic_country_test.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestTrafficCountryDetailsUseHistoryAndFilters(t *testing.T) {
+	s, a := trafficFixture(t)
+	if _, err := s.SaveTrafficSettings(TrafficSettings{Enabled: true, AgentID: a.ID, MonitoringRules: []MonitoringRule{{IP: "8.8.8.8"}}}); err != nil {
+		t.Fatal(err)
+	}
+	events := []TrafficEvent{}
+	for i := 0; i < 120; i++ {
+		events = append(events, TrafficEvent{ID: fmt.Sprint("http-", i), Time: time.Now().Unix(), Kind: "request", IP: "8.8.8.8", Domain: "example.test", Path: "/", Status: 200})
+	}
+	events = append(events, TrafficEvent{ID: "alert", Time: time.Now().Unix(), Kind: "alert", IP: "8.8.8.8", Domain: "example.test", Reason: "test"})
+	if err := s.SaveTraffic(a.ID, TrafficBatch{Events: events}); err != nil {
+		t.Fatal(err)
+	}
+	v, err := s.TrafficView("", "", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(v.Events) != 100 || len(v.CountryDetails) != 1 {
+		t.Fatalf("events=%d countries=%+v", len(v.Events), v.CountryDetails)
+	}
+	d := v.CountryDetails[0]
+	if d.Requests != 120 || d.UniqueIPs != 1 || d.Alerts != 1 || d.LastSeen == 0 {
+		t.Fatalf("%+v", d)
+	}
+	v, err = s.TrafficView("example.test", "", false, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(v.CountryDetails) != 1 || v.CountryDetails[0].Requests != 0 || v.CountryDetails[0].Alerts != 1 {
+		t.Fatalf("filter: %+v", v.CountryDetails)
+	}
+	v, err = s.TrafficView("other.test", "", false)
+	if err != nil || len(v.CountryDetails) != 0 {
+		t.Fatalf("domain: %+v %v", v.CountryDetails, err)
+	}
+}
--- a/traffic_history.go
+++ b/traffic_history.go
@@ -0,0 +1,144 @@
+package main
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type TrafficIPDetail struct {
+	IP       string `json:"ip"`
+	Country  string `json:"country"`
+	Requests int64  `json:"requests"`
+	LastSeen int64  `json:"lastSeen"`
+	City     string `json:"city,omitempty"`
+	Region   string `json:"region,omitempty"`
+}
+type TrafficHistory struct {
+	Events      []TrafficEvent    `json:"events"`
+	IPs         []TrafficIPDetail `json:"ips"`
+	Total       int64             `json:"total"`
+	Page        int               `json:"page"`
+	PageSize    int               `json:"pageSize"`
+	Snapshot    int64             `json:"snapshot"`
+	MaxSequence int64             `json:"maxSequence"`
+	CityReady   bool              `json:"cityReady"`
+}
+
+func (s *Store) trafficHistoryRoute(mux *http.ServeMux) {
+	mux.HandleFunc("/api/traffic/history", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "GET" {
+			w.WriteHeader(405)
+			return
+		}
+		if !s.TrafficSettings().Enabled {
+			http.Error(w, "Карта отключена", 404)
+			return
+		}
+		q := r.URL.Query()
+		page, _ := strconv.Atoi(q.Get("page"))
+		snapshot, _ := strconv.ParseInt(q.Get("snapshot"), 10, 64)
+		maxSeq, _ := strconv.ParseInt(q.Get("maxSequence"), 10, 64)
+		if q.Get("maxSequence") == "0" {
+			maxSeq = -1
+		}
+		if page < 0 || page > 10000 {
+			http.Error(w, "Invalid page", 400)
+			return
+		}
+		kind := q.Get("kind")
+		metricType := q.Get("type")
+		if metricType != "" && metricType != "request" && metricType != "alert" && metricType != "decision" {
+			http.Error(w, "Invalid type", 400)
+			return
+		}
+		if kind != "" && kind != "request" && kind != "alert" && kind != "decision" {
+			http.Error(w, "Invalid kind", 400)
+			return
+		}
+		result, err := s.TrafficHistory(q.Get("domain"), kind, q.Get("country"), q.Get("ip"), q.Get("type"), q.Get("external") == "1", q.Get("hideMonitoring") == "1", q.Get("group") == "ip", page, snapshot, maxSeq)
+		writeJSON(w, result, err)
+	})
+}
+func (s *Store) TrafficHistory(domain, kind, country, ip, metricType string, external, hide, group bool, page int, snapshot, maxSeq int64) (TrafficHistory, error) {
+	now := time.Now().Unix()
+	if snapshot <= 0 || snapshot > now {
+		snapshot = now
+	}
+	if snapshot < now-86400 {
+		snapshot = now
+	}
+	settings := s.TrafficSettings()
+	v := TrafficHistory{Events: []TrafficEvent{}, IPs: []TrafficIPDetail{}, Page: page, PageSize: 50, Snapshot: snapshot, CityReady: trafficCityReady()}
+	if maxSeq == 0 {
+		if err := s.db.QueryRow(`SELECT COALESCE(MAX(seq),0) FROM traffic_events WHERE agent=?`, settings.AgentID).Scan(&maxSeq); err != nil {
+			return v, err
+		}
+	}
+	v.MaxSequence = maxSeq
+	where := ` WHERE agent=? AND ts>=? AND ts<=? AND seq<=?`
+	args := []any{settings.AgentID, snapshot - 86400, snapshot, maxSeq}
+	if hide {
+		clause, values := monitoringSQL(settings.MonitoringRules)
+		where += clause
+		args = append(args, values...)
+	}
+	if external {
+		where += ` AND country!='LAN'`
+	}
+	for _, filter := range []struct{ column, value string }{{"domain", domain}, {"kind", kind}, {"kind", metricType}, {"country", country}, {"ip", ip}} {
+		if filter.value != "" {
+			where += " AND " + filter.column + "=?"
+			args = append(args, filter.value)
+		}
+	}
+	count := "COUNT(*)"
+	if group {
+		where += ` AND kind='request'`
+		count = "COUNT(DISTINCT ip)"
+	}
+	if err := s.db.QueryRow("SELECT "+count+" FROM traffic_events"+where, args...).Scan(&v.Total); err != nil {
+		return v, err
+	}
+	paged := append(append([]any{}, args...), v.PageSize, page*v.PageSize)
+	if group {
+		rows, err := s.db.Query(`SELECT ip,MIN(country),COUNT(*),MAX(ts) FROM traffic_events`+where+` GROUP BY ip ORDER BY COUNT(*) DESC,ip LIMIT ? OFFSET ?`, paged...)
+		if err != nil {
+			return v, err
+		}
+		defer rows.Close()
+		for rows.Next() {
+			var item TrafficIPDetail
+			if err = rows.Scan(&item.IP, &item.Country, &item.Requests, &item.LastSeen); err != nil {
+				return v, err
+			}
+			item.City, item.Region = lookupTrafficCity(item.IP)
+			v.IPs = append(v.IPs, item)
+		}
+		return v, rows.Err()
+	}
+	rows, err := s.db.Query(`SELECT seq,event_id,ts,kind,ip,domain,method,path,status,reason,country,agent FROM traffic_events`+where+` ORDER BY ts DESC,seq DESC LIMIT ? OFFSET ?`, paged...)
+	if err != nil {
+		return v, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var e TrafficEvent
+		if err = rows.Scan(&e.Sequence, &e.ID, &e.Time, &e.Kind, &e.IP, &e.Domain, &e.Method, &e.Path, &e.Status, &e.Reason, &e.Country, &e.Agent); err != nil {
+			return v, err
+		}
+		e.Monitoring = isMonitoringRequest(e, settings.MonitoringRules)
+		e.City, e.Region = lookupTrafficCity(e.IP)
+		v.Events = append(v.Events, e)
+	}
+	return v, rows.Err()
+}
+func cityName(names map[string]string) string {
+	for _, lang := range []string{"ru", "en"} {
+		if s := strings.TrimSpace(names[lang]); s != "" {
+			return s
+		}
+	}
+	return ""
+}
--- a/traffic_history_test.go
+++ b/traffic_history_test.go
@@ -0,0 +1,109 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestTrafficHistoryFullPaginationAndSnapshot(t *testing.T) {
+	s, a := trafficFixture(t)
+	if _, err := s.SaveTrafficSettings(TrafficSettings{Enabled: true, AgentID: a.ID}); err != nil {
+		t.Fatal(err)
+	}
+	now := time.Now().Unix()
+	batch := TrafficBatch{}
+	for i := 0; i < 137; i++ {
+		batch.Events = append(batch.Events, TrafficEvent{ID: fmt.Sprint(i), Time: now - 60, Kind: "request", IP: "8.8.8.8", Domain: "example.test"})
+	}
+	batch.Events = append(batch.Events, TrafficEvent{ID: "old-alert", Time: now - 3600, Kind: "alert", IP: "1.1.1.1", Domain: "other.test"})
+	if err := s.SaveTraffic(a.ID, batch); err != nil {
+		t.Fatal(err)
+	}
+	first, err := s.TrafficHistory("", "request", "", "", "", false, false, false, 0, now, 0)
+	if err != nil || first.Total != 137 || len(first.Events) != 50 {
+		t.Fatalf("first: %+v %v", first, err)
+	}
+	if err := s.SaveTraffic(a.ID, TrafficBatch{Events: []TrafficEvent{{ID: "new", Time: now - 60, Kind: "request", IP: "8.8.8.8"}}}); err != nil {
+		t.Fatal(err)
+	}
+	seen := map[int64]bool{}
+	for page := 0; page < 3; page++ {
+		h, err := s.TrafficHistory("", "request", "", "", "", false, false, false, page, first.Snapshot, first.MaxSequence)
+		if err != nil || h.Total != 137 {
+			t.Fatalf("page %d: %v total %d", page, err, h.Total)
+		}
+		for _, e := range h.Events {
+			if seen[e.Sequence] {
+				t.Fatal("duplicate page event")
+			}
+			seen[e.Sequence] = true
+		}
+	}
+	if len(seen) != 137 {
+		t.Fatalf("missing history: %d", len(seen))
+	}
+	h, err := s.TrafficHistory("other.test", "alert", "", "", "", false, false, false, 0, now, 0)
+	if err != nil || h.Total != 1 || h.Events[0].ID != "old-alert" {
+		t.Fatalf("old alert missing: %+v %v", h, err)
+	}
+	h, err = s.TrafficHistory("", "alert", "", "", "request", false, false, false, 0, now, 0)
+	if err != nil || h.Total != 0 {
+		t.Fatal("metric must respect global kind filter")
+	}
+	h, err = s.TrafficHistory("example.test", "", "", "", "", false, false, true, 0, now, 0)
+	if err != nil || h.Total != 1 || len(h.IPs) != 1 || h.IPs[0].Requests != 137 {
+		t.Fatalf("IP summary %+v %v", h, err)
+	}
+	h, err = s.TrafficHistory("", "", "ZZ", "", "", false, false, false, 0, now, 0)
+	if err != nil || h.Total != 0 {
+		t.Fatal("country filter ignored")
+	}
+	h, err = s.TrafficHistory("", "", "", "1.1.1.1", "", false, false, false, 0, now, 0)
+	if err != nil || h.Total != 1 {
+		t.Fatal("IP filter ignored")
+	}
+}
+func TestCityNamesAndLocalAddresses(t *testing.T) {
+	if cityName(map[string]string{"ru": "Москва", "en": "Moscow"}) != "Москва" || cityName(map[string]string{"en": "Amsterdam"}) != "Amsterdam" {
+		t.Fatal("city localization")
+	}
+	for _, ip := range []string{"192.168.0.10", "127.0.0.1", "::1", "fe80::1", "invalid"} {
+		c, r := lookupTrafficCity(ip)
+		if c != "" || r != "" {
+			t.Fatal("local IP geolocated")
+		}
+	}
+}
+
+func TestTrafficHistoryMonitoringAndAgentIsolation(t *testing.T) {
+	s, a := trafficFixture(t)
+	s.SaveTrafficSettings(TrafficSettings{Enabled: true, AgentID: a.ID, MonitoringRules: []MonitoringRule{{IP: "192.168.0.10"}}})
+	now := time.Now().Unix()
+	batch := TrafficBatch{Events: []TrafficEvent{{ID: "check", Time: now, Kind: "request", IP: "192.168.0.10"}, {ID: "alert", Time: now, Kind: "alert", IP: "192.168.0.10"}, {ID: "public", Time: now, Kind: "request", IP: "8.8.8.8"}}}
+	if err := s.SaveTraffic(a.ID, batch); err != nil {
+		t.Fatal(err)
+	}
+	token, _ := s.CreateAgentEnrollmentToken()
+	other, err := s.EnrollAgent(agentEnrollmentRequest{Token: token, Name: "other", VMID: 103})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = s.SaveTraffic(other.ID, batch); err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range []struct {
+		external, hide bool
+		want           int64
+	}{{false, false, 3}, {false, true, 2}, {true, false, 1}, {true, true, 1}} {
+		h, err := s.TrafficHistory("", "", "", "", "", tc.external, tc.hide, false, 0, now, 0)
+		if err != nil || h.Total != tc.want {
+			t.Fatalf("filters %+v total=%d err=%v", tc, h.Total, err)
+		}
+		for _, e := range h.Events {
+			if e.Agent != a.ID {
+				t.Fatal("foreign agent leaked")
+			}
+		}
+	}
+}
--- a/traffic_map_cities.go
+++ b/traffic_map_cities.go
@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+type TrafficMapCity struct {
+	TrafficCityLocation
+	Country   string `json:"country"`
+	Requests  int64  `json:"requests"`
+	UniqueIPs int64  `json:"uniqueIps"`
+	Alerts    int64  `json:"alerts"`
+	Decisions int64  `json:"decisions"`
+	LastSeen  int64  `json:"lastSeen"`
+}
+
+func (s *Store) trafficMapCities(where string, args []any) ([]TrafficMapCity, bool, error) {
+	rows, err := s.db.Query(`SELECT ip,country,SUM(kind='request'),SUM(kind='alert'),SUM(kind='decision'),MAX(ts) FROM traffic_events`+where+` GROUP BY ip,country`, args...)
+	if err != nil {
+		return nil, false, err
+	}
+	defer rows.Close()
+	groups := map[string]*TrafficMapCity{}
+	for rows.Next() {
+		var ip, country string
+		var requests, alerts, decisions, last int64
+		if err = rows.Scan(&ip, &country, &requests, &alerts, &decisions, &last); err != nil {
+			return nil, false, err
+		}
+		g := lookupTrafficCityLocation(ip)
+		if !g.Located {
+			continue
+		}
+		key := fmt.Sprintf("%s/%s/%s/%.5f/%.5f", country, g.Region, g.City, g.Latitude, g.Longitude)
+		c := groups[key]
+		if c == nil {
+			c = &TrafficMapCity{TrafficCityLocation: g, Country: country}
+			groups[key] = c
+		}
+		c.Requests += requests
+		c.Alerts += alerts
+		c.Decisions += decisions
+		if requests > 0 {
+			c.UniqueIPs++
+		}
+		if last > c.LastSeen {
+			c.LastSeen = last
+		}
+	}
+	if err = rows.Err(); err != nil {
+		return nil, false, err
+	}
+	result := make([]TrafficMapCity, 0, len(groups))
+	for _, c := range groups {
+		result = append(result, *c)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		a, b := result[i], result[j]
+		x, y := a.Requests+a.Alerts+a.Decisions, b.Requests+b.Alerts+b.Decisions
+		if x != y {
+			return x > y
+		}
+		return fmt.Sprint(a.Country, a.Region, a.City, a.Latitude, a.Longitude) < fmt.Sprint(b.Country, b.Region, b.City, b.Latitude, b.Longitude)
+	})
+	limited := len(result) > 500
+	if limited {
+		result = result[:500]
+	}
+	return result, limited, nil
+}
--- a/web.go
+++ b/web.go
@@ -890,6 +890,7 @@ footer{color:#657581;font-size:12px;margin-top:17px}
 <label class="field"><span>Правила мониторинга: IP | домен | префикс пути</span><textarea id="monitoringRules" rows="4" placeholder="192.168.0.10" style="width:100%;font:12px monospace;background:var(--bg);color:var(--text);border:1px solid var(--border);border-radius:8px;padding:10px"></textarea></label>
 <p class="settings-note">Одно правило на строку, до 32. Домен и путь необязательны; внутри правила условия объединяются. IP без уточнений помечает HTTP-проверки и сетевые потоки этого инициатора. Домен/путь применяются только к HTTP. Скрытие — фильтр просмотра: история сохраняется, срабатывания и решения CrowdSec не скрываются. Пример: 192.168.0.10 | example.org | /health</p>
 <button class="save-settings" id="saveTrafficSettings">Сохранить</button><span id="trafficSettingsStatus" role="status"></span>
+ <div class="settings-group"><button class="theme-option" id="installCityDatabase">Установить базу городов (~58 МБ)</button><div class="settings-note" id="cityDatabaseStatus">DB-IP City Lite: локальная приблизительная геолокация, без отправки IP внешним сервисам. Устанавливается на сервер Dashboard.</div></div>
 </div></div>
 <div class="settings-body settings-panel" data-settings-panel="updates" hidden>
  <div class="detail-grid">
@@ -1038,10 +1039,12 @@ async function loadTrafficSettings(){try{
 el('trafficCountry').innerHTML='<option value="">Не задана</option>'+world.filter(c=>c.code&&c.code!=='-99').sort((a,b)=>a.name.localeCompare(b.name,'ru')).map(c=>'<option value="'+safe(c.code)+'">'+safe(c.name)+'</option>').join('');el('trafficCountry').value=settings.serverCountry;el('trafficSettingsStatus').textContent='';
 }catch(e){el('trafficSettingsStatus').textContent='Не удалось загрузить настройки';}}
 el('trafficSettingsTab').addEventListener('click',loadTrafficSettings);
+ fetch('/api/settings/traffic/city-database').then(r=>r.ok?r.json():null).then(d=>{if(!d)return;const b=el('installCityDatabase');if(d.ready){b.disabled=true;b.textContent='База городов установлена'}if(d.message)el('cityDatabaseStatus').textContent=d.message}).catch(()=>{});
+ el('installCityDatabase').onclick=async()=>{const b=el('installCityDatabase'),status=el('cityDatabaseStatus');b.disabled=true;try{let r=await fetch('/api/settings/traffic/city-database',{method:'POST'});if(!r.ok)throw Error('Не удалось начать загрузку');let result=await r.json();status.textContent=result.message||'База уже установлена';while(result.running){await new Promise(resolve=>setTimeout(resolve,2000));r=await fetch('/api/settings/traffic/city-database');if(!r.ok)throw Error('Не удалось прочитать состояние');result=await r.json();status.textContent=result.message}b.textContent=result.ready?'База городов установлена':'Повторить установку базы';b.disabled=result.ready}catch(e){status.textContent=e.message;b.disabled=false}};
 el('saveTrafficSettings').onclick=async()=>{const button=el('saveTrafficSettings');button.disabled=true;try{const response=await fetch('/api/settings/traffic',{method:'PUT',headers:{'Content-Type':'application/json'},body:JSON.stringify({monitoringRules:el('monitoringRules').value.split('\n').filter(line=>line.trim()).map(line=>{const parts=line.split('|').map(v=>v.trim());if(parts.length>3)throw Error('В правиле допускается три поля: IP | домен | путь');return {ip:parts[0],domain:parts[1]||'',pathPrefix:parts[2]||''}}),enabled:el('trafficEnabled').checked,networkEnabled:el('networkEnabled').checked,agentId:el('trafficAgent').value,serverCountry:el('trafficCountry').value})});if(!response.ok)throw Error(await response.text());el('trafficLink').hidden=!el('trafficEnabled').checked;el('trafficSettingsStatus').textContent='Сохранено. Фильтры применяются сразу, настройки сбора — при следующем отчёте агента.';}catch(e){el('trafficSettingsStatus').textContent=e.message||'Ошибка сохранения';}finally{button.disabled=false;}};
 if(location.hash==='#traffic-settings'){el('settingsDialog').showModal();el('trafficSettingsTab').click();}
 el('agentServerURL').value=location.origin;
-el('createAgentToken').onclick=async()=>{const button=el('createAgentToken'),server=el('agentServerURL').value.trim().replace(/\/$/,''),vmid=Number(el('agentVMID').value)||0;if(!/^https?:\/\//.test(server)){alert('Укажите полный адрес Dashboard, доступный из VM/LXC.');return}button.disabled=true;button.textContent='Создаём токен…';try{const response=await fetch('/api/agents/enrollment-token',{method:'POST'});if(!response.ok)throw new Error(await response.text());const value=await response.json(),quote=v=>"'"+String(v).replaceAll("'","'\"'\"'")+"'";el('agentInstallCommand').textContent='curl -fsSL https://git.myown.center/maxim/ProxmoxDash/raw/branch/main/scripts/install-agent.sh | DASHBOARD_URL='+quote(server)+' ENROLL_TOKEN='+quote(value.token)+' VMID='+quote(vmid)+' sh';el('agentInstallBlock').hidden=false}catch(e){alert('Не удалось создать токен: '+e.message)}finally{button.disabled=false;button.textContent='Создать команду установки или обновления'}};
+el('createAgentToken').onclick=async()=>{const button=el('createAgentToken'),server=el('agentServerURL').value.trim().replace(/\/$/,''),vmid=Number(el('agentVMID').value)||0;if(!/^https?:\/\//.test(server)){alert('Укажите полный адрес Dashboard, доступный из VM/LXC.');return}button.disabled=true;button.textContent='Создаём токен…';try{const response=await fetch('/api/agents/enrollment-token',{method:'POST'});if(!response.ok)throw new Error(await response.text());const value=await response.json(),quote=v=>"'"+String(v).replaceAll("'","'\"'\"'")+"'";el('agentInstallCommand').textContent='(command -v curl >/dev/null 2>&1 || apk add --no-cache curl ca-certificates) && curl -fsSL https://git.myown.center/maxim/ProxmoxDash/raw/branch/main/scripts/install-agent.sh | DASHBOARD_URL='+quote(server)+' ENROLL_TOKEN='+quote(value.token)+' VMID='+quote(vmid)+' sh';el('agentInstallBlock').hidden=false}catch(e){alert('Не удалось создать токен: '+e.message)}finally{button.disabled=false;button.textContent='Создать команду установки или обновления'}};
 el('agentSettingsList').onclick=async event=>{const detail=event.target.closest('[data-agent-detail]');if(detail){const agent=currentAgents.find(v=>v.id===detail.dataset.agentDetail);if(agent)openAgentDetail(agent);return}const button=event.target.closest('[data-agent-delete]');if(!button||!confirm('Удалить агент? Для повторного подключения потребуется новый токен.'))return;button.disabled=true;const response=await fetch('/api/agents?id='+encodeURIComponent(button.dataset.agentDelete),{method:'DELETE'});if(response.ok)button.closest('.disk-item').remove();else{button.disabled=false;alert(await response.text())}};
 async function loadAgentActions(){const response=await fetch('/api/agent-actions');if(!response.ok)return;const items=await response.json()||[];el('agentActionLog').innerHTML=items.length?items.map(v=>'<article class="disk-item"><div class="disk-top"><div><div class="disk-model">'+safe(v.agentName)+' · '+safe(v.action)+'</div><div class="disk-meta">'+safe(v.target||'без цели')+' · '+new Date(v.requestedAt*1000).toLocaleString('ru-RU')+'</div></div><span class="badge '+(v.status==='failed'?'bad':v.status==='completed'?'':'warn')+'">'+safe(v.status)+'</span></div>'+(v.result?'<div class="settings-note">'+safe(v.result)+'</div>':'')+'</article>').join(''):'<span class="empty">Действий пока не было.</span>'}loadAgentActions().catch(()=>{});
 async function loadThresholds(){const response=await fetch('/api/settings/alerts');if(!response.ok)return;alertSettings=await response.json();document.querySelectorAll('[data-threshold]').forEach(input=>input.value=alertSettings[input.dataset.threshold]??'')}
Author	SHA1	Message	Date
Maxim	46bd6e8be6	Plot city-level traffic activity from local GeoIP coordinates	2026-10-15 20:48:04 +03:00
Maxim	03b6c1f289	Add event filters to traffic dialogs and mirror city database in Gitea	2026-10-15 20:41:07 +03:00
Maxim	14d57120cd	Fix traffic map zoom and add paginated history with local city GeoIP	2026-10-15 20:26:14 +03:00
Maxim	c3b2a10d2f	Add light traffic theme, interactive map and metric detail dialogs	2026-10-15 20:11:51 +03:00
Maxim	72bebdc2eb	Support Alpine OpenRC agents and discover Docker NPMplus and CrowdSec	2026-10-14 20:37:34 +03:00