Go Collector — Alternativa ao Radio Collector Node.js

Status: ⏸️ Suspenso (dev) — pode ser reactivado em produção
Data: 2026-04-08
Localização: tools/go-collector/ > Referência: IDEAL_ARCHITECTURE.md (visão norte-estrela)

Nota (2026-04-08): O Go Collector está suspenso devido a custos e limitações de Cosmos DB RU/s.
A recolha de ICY history é agora feita no dispositivo do utilizador via just_audio na app Flutter.
O Go Collector poderá ser reactivado em produção no futuro quando o custo de Cosmos DB for optimizado.

Contexto

O pipeline de recolha de metadados agora-a-tocar (now-playing) era executado pelo radio-collector (Node.js/NestJS), integrado no Worker via BullMQ. Esta abordagem apresentava problemas estruturais:

O Go Collector é uma alternativa standalone em Go que substitui todo o pipeline Node.js com 7.5× menos memória e sem dependência do BullMQ.

Comparação

Arquitectura

Estrutura de Ficheiros

tools/go-collector/
├── go.mod                   # Module + deps
├── go.sum                   # Checksums
├── Dockerfile               # Multi-stage: golang:1.24-alpine → scratch
├── main.go                  # 254 LOC — loop, collectOne, health endpoint
├── config.go                # 192 LOC — env vars, Azure Redis parser
├── db.go                    # 168 LOC — MongoDB: 4 write operations
├── redis.go                 #  96 LOC — NP cache, meta-hash, pub/sub
├── loader.go                #  68 LOC — radio query (eligible)
├── router.go                #  78 LOC — domain-based adapter routing
├── track.go                 # 166 LOC — normalize, classify, confidence
├── icy.go                   # 235 LOC — binary ICY protocol prober
├── adapters_radioking.go    # 106 LOC — RadioKing widget API
├── adapters_triton.go       # 102 LOC — Triton Digital NowPlaying XML
├── adapters_rtp.go          #  93 LOC — RTP live channel JSON
├── adapters_radiojar.go     #  64 LOC — RadioJar station API
├── adapters_radiofrance.go  # 125 LOC — Radio France livemeta + time match
├── adapters_securenet.go    #  74 LOC — SecureNetSystems XSPF XML
├── adapters_rcom.go         # 101 LOC — Grupo Renascença UTF-16LE XML
├── adapters_zenofm.go       #  17 LOC — strip .m3u → ICY
├── adapters_amperwave.go    #  62 LOC — HEAD redirect → ICY
└── adapters_bauer.go        # 249 LOC — ICY + XML metadata + ad skip
                              ─────────
                              2 250 LOC total

Variáveis de Ambiente

Ciclo de Recolha

┌─────────────────────────────────────────────────────────┐
│ 1. LoadEligibleRadios()                                 │
│    filter: is_active=true, enable_icy_epg=true,         │
│            stream_url exists, failures < 5              │
│    sort: now_playing_updated_at ASC (stalest first)     │
│    limit: COLLECTION_LIMIT                              │
├─────────────────────────────────────────────────────────┤
│ 2. Para cada rádio (goroutine pool, sem=CONCURRENCY):   │
│    a) ResolveAdapter(stream_url) → adapter match        │
│    b) FetchWithAdapter() → ProbeResult                  │
│    c) normalizeTitle + classifyContent + confidence      │
│    d) CheckAndSetMetaHash (Redis dedup 300s)            │
│    e) Se erro → IncrementFailures, skip                 │
├─────────────────────────────────────────────────────────┤
│ 3. DB writes (sem=DB_WRITE_CONCURRENCY):                │
│    a) UpdateRadioNowPlaying (always)                    │
│    b) InsertIcyHistory (dedup vs last entry)            │
│    c) UpsertMusicLink + youtube_search_url (if music)   │
│    d) RecordPlay — play_count++ (if music)              │
├─────────────────────────────────────────────────────────┤
│ 4. Redis (se track mudou):                              │
│    a) SET radio:{id}:np (120s TTL)                      │
│    b) PUBLISH np:events (track change event)            │
├─────────────────────────────────────────────────────────┤
│ 5. Sleep(COLLECTOR_INTERVAL), goto 1                    │
└─────────────────────────────────────────────────────────┘

Adapter Routing

O router.go mapeia domínios de stream_url para o adapter correcto:

MusicLink — YouTube URL

Para tracks classificadas como music com artist+track:

youtube_search_url = https://music.youtube.com/search?q={urlEncode(artist + " " + track)}

Criado via $setOnInsert com status: "enriched" — sem estado PENDING intermediário. Isto elimina a necessidade do job de enriquecimento separado que existia no pipeline Node.js.

Operações MongoDB

Redis Keys

Decisões de Design

1. Sem ActiveListenerService — Recolhe todas as rádios elegíveis, não apenas as com listeners activos. Simplifica a arquitectura e garante dados frescos para todos.

2. MusicLink ENRICHED directo — Elimina o estado PENDING e o job de enriquecimento. O youtube_search_url é gerado no momento da inserção.

3. Standalone loop, sem BullMQ — Go gere o seu próprio schedule com time.After + context.Context para graceful shutdown.

4. DB write semaphore — Limita escritas concorrentes a 20, matching o padrão Node.js para evitar saturar Cosmos DB RUs.

5. Two-tier ICY fallback — Primeira tentativa a 8s, retry a 20s se falhar. Cobre streams lentos sem penalizar o ciclo inteiro.

6. Preroll ad skip (Bauer) — Até 50 blocos ICY de preroll ignorados antes de extrair metadata real.

Como correr em dev

Via Docker Compose

cd Audissey
docker compose up go-collector

O serviço liga-se automaticamente ao MongoDB e Redis do compose (porta 8081 → 8080 interno).

Build manual

cd tools/go-collector
go build -o collector .
MONGO_URI="mongodb://admin:password@localhost:27017/audissey?authSource=admin" \
REDIS_URL="redis://localhost:6379" \
LOG_LEVEL=debug \
./collector

Health check

curl http://localhost:8081/health
# {"service":"go-collector","status":"ok"}

Verificação

Relação com a Arquitectura Ideal

Este Go Collector implementa o componente A (ICY Probe Service) da Ideal Architecture, mas de forma pragmática e com custo zero de infraestrutura adicional:

• Sem Azure Service Bus (escrita directa ao DB)
• Sem separação writer/enricher (tudo inline no mesmo binário)
• Sem SignalR (pub/sub Redis existente)

Se a escala exigir no futuro, o collector pode ser refactored para emitir eventos em vez de escrever directamente, alinhando com a arquitectura norte-estrela.

Ficheiros Relacionados