feat(dashboard): live listener map + quarter/year/lifetime traffic + source-format display

GEO MAP
  - relay/geoip.go: free, key-less country lookup using DB-IP's
    ip-to-country-lite database (CC-BY-4.0, no signup, no quota).
    Auto-downloads to /var/lib/tinyice/geoip on first run, refreshes
    monthly. Lookup is sub-millisecond, lock-free reads, returns ISO
    alpha-2 country code or "" for private/loopback IPs.
  - relay/geoip_centroids.go: embedded Natural Earth centroid table
    (~6 KB, ISO -> name + lat/lon) so the dashboard can plot bubbles
    without an extra round-trip.
  - server/geo_tracker.go: live (country, mount) listener counter
    updated by handleListener via Add/Remove on every subscribe /
    unsubscribe.
  - GET /admin/geo: returns aggregated per-country listener counts,
    sorted by listener count DESC. Optional ?mount= filter.
  - server/frontend/src/components/GeoMapCard.tsx: Leaflet map using
    CartoDB Dark Matter tiles (no API key; OpenStreetMap data + CARTO
    attribution). Refreshes every 15 s. Each country renders as a
    circle marker at its centroid; radius scales with sqrt(listeners).

TRAFFIC WINDOWS
  - /admin/traffic now also returns quarter (90 d), year (365 d) and
    lifetime totals alongside day/week/month/all. Same shape, same
    aggregation logic.
  - TrafficTotalsCard reworked into a compact dense table — six rows
    of (window, in, out, mounts) with arrow glyphs in the header.

SOURCE FORMAT
  - streamEventInfo gains source_mount / source_type / source_bitrate
    fields populated for transcoded outputs. Operator can see at a
    glance what's being converted into what.
  - Dashboard streams table now renders "<src-format> -> <out-format>"
    for transcoded mounts (e.g. "OPUS 160k -> MP3 320k").

Author: DatanoiseTV

go.mod

@@ -44,6 +44,7 @@ require (
 	github.com/mewkiz/pkg v0.0.0-20250417130911-3f050ff8c56d // indirect
 	github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985 // indirect
 	github.com/mitchellh/mapstructure v1.4.1 // indirect
+	github.com/oschwald/maxminddb-golang v1.13.1 // indirect
 	github.com/pion/datachannel v1.6.0 // indirect
 	github.com/pion/dtls/v3 v3.1.2 // indirect
 	github.com/pion/ice/v4 v4.2.1 // indirect

go.sum

@@ -72,6 +72,8 @@ github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985 h1:h8O1byDZ1uk6RUXMhj1
 github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985/go.mod h1:uiPmbdUbdt1NkGApKl7htQjZ8S7XaGUAVulJUJ9v6q4=
 github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag=
 github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/oschwald/maxminddb-golang v1.13.1 h1:G3wwjdN9JmIK2o/ermkHM+98oX5fS+k5MbwsmL4MRQE=
+github.com/oschwald/maxminddb-golang v1.13.1/go.mod h1:K4pgV9N/GcK694KSTmVSDTODk4IsCNThNdTmnaBZ/F8=
 github.com/pion/datachannel v1.6.0 h1:XecBlj+cvsxhAMZWFfFcPyUaDZtd7IJvrXqlXD/53i0=
 github.com/pion/datachannel v1.6.0/go.mod h1:ur+wzYF8mWdC+Mkis5Thosk+u/VOL287apDNEbFpsIk=
 github.com/pion/dtls/v3 v3.1.2 h1:gqEdOUXLtCGW+afsBLO0LtDD8GnuBBjEy6HRtyofZTc=

relay/geoip.go

@@ -0,0 +1,227 @@
+package relay
+
+import (
+	"compress/gzip"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/DatanoiseTV/tinyice/logger"
+	"github.com/oschwald/maxminddb-golang"
+)
+
+// GeoIP — free, key-less country lookup for listener locations.
+//
+// We pull DB-IP's "ip-to-country-lite" database, published monthly
+// under CC-BY-4.0 with no API key, no signup, and no per-request
+// quota. The .mmdb file is ~6 MB; we cache it under
+// dataDir/dbip-country-lite.mmdb and refresh whenever it crosses
+// 30 days stale.
+//
+// Attribution requirement (CC-BY-4.0): the dashboard surfaces
+// "GeoIP data: db-ip.com / CC BY 4.0" near the map.
+
+const (
+	dbipFilename     = "dbip-country-lite.mmdb"
+	dbipMaxAge       = 30 * 24 * time.Hour
+	dbipDownloadTmpl = "https://download.db-ip.com/free/dbip-country-lite-%s.mmdb.gz"
+	dbipUserAgent    = "tinyice-geoip/1.0 (+https://github.com/DatanoiseTV/tinyice)"
+)
+
+// GeoLookup is the read side of the geoip cache. Listener-connect
+// hot path takes a read lock per Lookup; a periodic update goroutine
+// takes the write lock to swap in a fresh mmdb. Lookup is allocation-
+// free (the maxminddb library reads into the supplied struct).
+type GeoLookup struct {
+	mu     sync.RWMutex
+	reader *maxminddb.Reader
+	loaded time.Time
+	dir    string
+}
+
+// NewGeoLookup loads dataDir/dbip-country-lite.mmdb if present and
+// kicks off a background updater. Returns a non-nil GeoLookup even
+// when the file is absent or corrupt — Lookup just returns "" until
+// the first download lands. Pass an empty dir to disable persistence
+// + auto-update entirely (useful in tests).
+func NewGeoLookup(dataDir string) *GeoLookup {
+	g := &GeoLookup{dir: dataDir}
+	if dataDir == "" {
+		return g
+	}
+	_ = os.MkdirAll(dataDir, 0o755)
+	if err := g.tryLoad(); err != nil {
+		logger.L.Infof("geoip: no usable database yet (%v); will fetch in background", err)
+	}
+	go g.updater()
+	return g
+}
+
+func (g *GeoLookup) path() string { return filepath.Join(g.dir, dbipFilename) }
+
+// tryLoad opens the cached mmdb under the data directory and swaps
+// it in atomically.
+func (g *GeoLookup) tryLoad() error {
+	p := g.path()
+	st, err := os.Stat(p)
+	if err != nil {
+		return err
+	}
+	rdr, err := maxminddb.Open(p)
+	if err != nil {
+		return err
+	}
+	g.mu.Lock()
+	if g.reader != nil {
+		_ = g.reader.Close()
+	}
+	g.reader = rdr
+	g.loaded = st.ModTime()
+	g.mu.Unlock()
+	logger.L.Infow("geoip: database loaded",
+		"path", p, "build", st.ModTime().UTC().Format(time.RFC3339), "size_kb", st.Size()/1024)
+	return nil
+}
+
+// Lookup returns an ISO-3166 alpha-2 country code (e.g. "DE") for
+// the given IP, or "" when the IP is private / loopback / not
+// resolvable / the database isn't loaded. Safe to call concurrently.
+func (g *GeoLookup) Lookup(ip string) string {
+	if g == nil || ip == "" {
+		return ""
+	}
+	addr := net.ParseIP(stripPort(ip))
+	if addr == nil || addr.IsLoopback() || addr.IsPrivate() ||
+		addr.IsLinkLocalUnicast() || addr.IsUnspecified() {
+		return ""
+	}
+	g.mu.RLock()
+	rdr := g.reader
+	g.mu.RUnlock()
+	if rdr == nil {
+		return ""
+	}
+	var rec struct {
+		Country struct {
+			ISOCode string `maxminddb:"iso_code"`
+		} `maxminddb:"country"`
+	}
+	if err := rdr.Lookup(addr, &rec); err != nil {
+		return ""
+	}
+	return strings.ToUpper(rec.Country.ISOCode)
+}
+
+func stripPort(s string) string {
+	if h, _, err := net.SplitHostPort(s); err == nil {
+		return h
+	}
+	return s
+}
+
+// updater runs forever. Sleeps until the loaded mmdb crosses
+// dbipMaxAge, then downloads the current month's release and
+// reloads. Failures retry with a 30 min → 6 h capped backoff.
+func (g *GeoLookup) updater() {
+	if g.dir == "" {
+		return
+	}
+	backoff := 30 * time.Minute
+	for {
+		g.mu.RLock()
+		age := time.Since(g.loaded)
+		hasReader := g.reader != nil
+		g.mu.RUnlock()
+		var delay time.Duration
+		switch {
+		case !hasReader:
+			delay = 0
+		case age >= dbipMaxAge:
+			delay = 0
+		default:
+			delay = dbipMaxAge - age
+		}
+		if delay > 0 {
+			time.Sleep(delay)
+		}
+		if err := g.fetchAndSwap(); err != nil {
+			logger.L.Warnw("geoip: update failed; will retry", "error", err.Error(), "retry_in", backoff)
+			time.Sleep(backoff)
+			if backoff < 6*time.Hour {
+				backoff *= 2
+			}
+			continue
+		}
+		backoff = 30 * time.Minute
+	}
+}
+
+// fetchAndSwap downloads the current month's lite mmdb and atomically
+// replaces the cached file + open reader. Tries the current month
+// first; on 404 (early-month publishing window) falls back to the
+// previous month.
+func (g *GeoLookup) fetchAndSwap() error {
+	now := time.Now().UTC()
+	candidates := []string{
+		now.Format("2006-01"),
+		now.AddDate(0, -1, 0).Format("2006-01"),
+	}
+	var lastErr error
+	for _, ym := range candidates {
+		url := fmt.Sprintf(dbipDownloadTmpl, ym)
+		if err := g.downloadTo(url, g.path()); err != nil {
+			lastErr = err
+			continue
+		}
+		return g.tryLoad()
+	}
+	if lastErr == nil {
+		lastErr = errors.New("no candidate URL succeeded")
+	}
+	return lastErr
+}
+
+func (g *GeoLookup) downloadTo(url, dest string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("User-Agent", dbipUserAgent)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("HTTP %s for %s", resp.Status, url)
+	}
+	gz, err := gzip.NewReader(resp.Body)
+	if err != nil {
+		return fmt.Errorf("gunzip: %w", err)
+	}
+	defer gz.Close()
+	tmp := dest + ".tmp"
+	f, err := os.Create(tmp)
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(f, gz); err != nil {
+		_ = f.Close()
+		_ = os.Remove(tmp)
+		return err
+	}
+	if err := f.Close(); err != nil {
+		return err
+	}
+	return os.Rename(tmp, dest)
+}