Come esportare i dati di utilizzo di rete di macOS

Hai finalmente beccato il picco. Per tre giorni ti sei chiesto perché l'uso internet di casa saltasse a ore casuali, e finalmente hai uno strumento aperto al momento giusto per vederlo. E adesso? Vuoi questi dati fuori dall'UI live e dentro qualcosa che puoi analizzare, condividere con un collega, o correlare contro un log server. La capacità di esportare l'uso della rete macOS conta più di quanto la gente pensi, e macOS ha opzioni decenti una volta che sai dove guardare.

Questo articolo passa attraverso i percorsi pratici: nettop -L per catture brevi, il log unificato per gli eventi di rete lato sistema, script di campionamento per CSV, e dove ova memorizza i suoi dati su disco.

Perché esportare l'uso della rete macOS in primo luogo

Qualche caso reale:

• Indagine su anomalie — hai visto un upload da 2 GB alle 3 di notte, vuoi graficare il processo sorgente attraverso la notte.
• Capacity planning — sei su una connessione a consumo o limitata (Starlink Roam, Wi-Fi hotel, tether mobile) e vuoi sapere cosa è sicuro lasciare attivo.
• Debug delle performance — il team server sta chiedendo quando sono iniziate le richieste lente, e vuoi sovrapporre l'uso di rete client-side ai log del server.
• Budget di banda per progetto — fatturi ai clienti a ore e vuoi un sanity check su cosa hanno caricato le loro pipeline di build ieri.
• Curiosità — semplicemente vuoi guardare i tuoi dati.

Per tutti questi, "apri Monitoraggio Attività e fissa" non basta. Ti servono dati su disco, in un formato che puoi manipolare.

Opzione 1: modalità log di nettop

Il percorso di export più semplice è integrato. nettop -L <count> gira in modalità log per <count> campioni, scaricando ogni campione come una riga di testo, ed esce. Combinato con -J per scegliere le colonne e -s per impostare l'intervallo, ottieni output pulito che puoi inoltrare in un file.

nettop -L 600 -s 1 -P -J bytes_in,bytes_out,interface,state \
  > ~/Desktop/nettop-10min.txt

Sono 600 campioni a intervalli di un secondo — dieci minuti di cattura. Ogni campione elenca ogni processo attivo con le colonne che hai chiesto.

L'output non è proprio CSV — ha un'intestazione per campione, righe vuote tra i campioni, e nomi di processi con spazi. Ma è parsabile. Un breve script awk o Python lo trasformerà in una tabella pulita.

Limiti del logging di nettop

• Cattura solo mentre gira. Se volevi sapere cosa è successo ieri, sei fregato.
• Riporta cumulativo-dall'avvio-del-processo di default; le delta le calcoli tu.
• I processi ausiliari appaiono come righe separate (nessun raggruppamento).
• Il formato del campione non è CSV first-class; aspettati di scrivere un parser.

Per catture ad-hoc di una specifica finestra temporale — "sto per pushare su GitHub, lasciami catturare cinque minuti intorno" — nettop -L è ottimo. Per dati continui, vuoi qualcos'altro.

Opzione 2: il log unificato

Il log unificato di macOS cattura eventi strutturati dai framework di sistema, incluso il networking. CFNetwork (il livello URLSession) e Network.framework emettono entrambi righe di log per ciclo di vita di connessione, handshake TLS, retry e fallimenti. Puoi estrarli a posteriori.

Per vedere cosa c'è ora, interroga l'ultima ora:

log show --last 1h --predicate 'subsystem == "com.apple.CFNetwork"' \
  --info --debug

Per esportare in un file:

log show --last 24h --predicate 'subsystem == "com.apple.CFNetwork"' \
  --style compact > ~/Desktop/cfnetwork-day.log

Predicati utili:

• subsystem == "com.apple.CFNetwork" — richieste URLSession, TLS, redirect
• subsystem == "com.apple.network" — cambi di path Network.framework, stato connessione
• process == "YourApp" — limita a un'app
• eventMessage CONTAINS "443" — ricerca testo dentro i messaggi di log

Il log unificato tiene grossomodo gli ultimi diversi giorni di eventi di sistema, a seconda del volume. Non è progettato per accounting di byte — è progettato per audit di eventi. Ma se la tua domanda è "la connessione a api.example.com è fallita alle 14:23", il log unificato lo sa.

log show vs log stream

log show legge il log storico. log stream osserva i nuovi eventi live. Usa log stream quando vuoi lasciare un terminale che gira e guardare gli eventi mentre accadono:

log stream --predicate 'subsystem == "com.apple.network"' --level debug

Inoltra in un file con >> per appendere una cattura rotante.

Opzione 3: uno script di campionamento custom

Se vuoi output CSV della banda per processo — il vero obiettivo per la maggior parte delle persone — puoi costruirlo in 20 righe di shell. L'idea: poll ogni N secondi, fai diff sui conteggi byte cumulativi, emetti CSV.

#!/usr/bin/env bash
# Sampler ingenuo della banda per processo.
INTERVAL=5
echo "timestamp,pid,process,delta_in,delta_out"
declare -A prev_in prev_out
while true; do
  ts=$(date +%s)
  while IFS=, read pid name in_bytes out_bytes; do
    pi=${prev_in[$pid]:-0}
    po=${prev_out[$pid]:-0}
    di=$((in_bytes - pi))
    do_=$((out_bytes - po))
    if (( di > 0 || do_ > 0 )); then
      echo "$ts,$pid,$name,$di,$do_"
    fi
    prev_in[$pid]=$in_bytes
    prev_out[$pid]=$out_bytes
  done < <(nettop -P -L 1 -J pid,interface,bytes_in,bytes_out 2>/dev/null \
            | awk 'NR>2 {print $2","$1","$3","$4}')
  sleep $INTERVAL
done

Questo è uno schizzo — codice da produzione gestirebbe le uscite di processo, il raggruppamento dei processi ausiliari, la rotazione dei log, e il fatto che il formato di output di nettop è fastidioso da parsare — ma mostra la forma. Campioni, fai diff, emetti CSV. Eseguilo sotto caffeinate o come launchd agent se vuoi che sopravviva allo sleep.

Vedi ova in azione

Un monitor della larghezza di banda nella barra dei menu visibile a colpo d'occhio — locale, firmato, ~3 MB.

Scarica per macOS

Opzione 4: il database locale di ova

Un monitor della larghezza di banda dedicato ti risparmia di scrivere lo script sopra. ova tiene un database SQLite in:

~/Library/Application Support/ova/

I contenuti sono gli stessi dati time-series che vedi nell'UI: byte in entrata e uscita per app, campionati a circa 1 Hz, con processi ausiliari raggruppati sotto la loro app principale. È locale, niente sync cloud, niente telemetria. Il file è tuo.

Poiché è SQLite, qualsiasi cosa possa leggere SQLite può leggerlo: la CLI sqlite3, il modulo sqlite3 di Python, DB Browser for SQLite, o una query rapida in DuckDB. Puoi:

• Esportare l'intera cronologia in CSV con un comando
• Eseguire aggregazioni ("quale app ha usato più banda questa settimana, per ora")
• Fare join contro i tuoi log (pipeline di build, log di accesso server, eventi del calendario)
• Fare backup sul tuo target di backup normale

Un export tipico in CSV usando sqlite3:

sqlite3 -header -csv \
  ~/Library/Application\ Support/ova/<file>.sqlite \
  "SELECT timestamp, app, bytes_in, bytes_out FROM samples \
   WHERE timestamp > strftime('%s','now','-7 days') \
   ORDER BY timestamp" > ~/Desktop/last-week.csv

Ricette pratiche, join e privacy

Una volta che hai un CSV — da qualsiasi fonte — qualche query ripaga lo sforzo.

Top app per settimana

SELECT app,
       SUM(bytes_in) / (1024*1024) AS mb_down,
       SUM(bytes_out) / (1024*1024) AS mb_up
  FROM samples
 WHERE timestamp > strftime('%s','now','-7 days')
 GROUP BY app
 ORDER BY (mb_down + mb_up) DESC
 LIMIT 20;

Quasi sempre racconta una storia chiara. Browser in cima, app di sync in mezzo, servizi di sistema in fondo.

Heatmap oraria

SELECT strftime('%H', timestamp, 'unixepoch', 'localtime') AS hour,
       SUM(bytes_in + bytes_out) / (1024*1024) AS mb
  FROM samples
 WHERE timestamp > strftime('%s','now','-30 days')
 GROUP BY hour
 ORDER BY hour;

Ti mostra quando il tuo traffico fa picco. Per la maggior parte: 9, 13 e 16, con una coda lunga di sync cloud durante la notte.

Rilevamento anomalie

SELECT app,
       date(timestamp, 'unixepoch', 'localtime') AS day,
       SUM(bytes_out) / (1024*1024) AS mb_up
  FROM samples
 GROUP BY app, day
HAVING mb_up > 500
 ORDER BY mb_up DESC;

Segnala qualsiasi app-giorno con più di 500 MB di upload. Una manciata è normale (Time Machine verso un target di rete, sync foto, trasferimenti file grandi). Un'intera lista di app sconosciute vale la pena di indagare.

Combinare fonti

Il flusso più forte usa più fonti contemporaneamente.

• ova per accounting di byte — cosa è stato usato, da quale app, quando
• Log unificato per gli eventi — quando sono iniziate le connessioni, fallite, riprovate
• tcpdump per il filo — quando qualcosa è genuinamente misterioso

Puoi farne join sul timestamp. Se ova mostra un upload da 200 MB di cloudd alle 3:14 di notte, il log unificato mostra cosa cloudd stava sincronizzando, e (se avevi una cattura pacchetti che girava) tcpdump mostra lo spazio IP di destinazione confermando che era iCloud.

Una nota sulla privacy

Qualsiasi cosa esporti dati di rete può far trapelare informazioni che non intendevi condividere. Hostname, anche path nel log unificato, possono rivelare quali servizi usi. Prima di mandare log a un collega o incollare in una chat:

• Togli gli indirizzi IP se identificano la tua rete di casa
• Redigi gli hostname che rivelano servizi personali
• Rimuovi i nomi dei processi che rivelano app che preferiresti non pubblicizzare

È anche perché gli strumenti solo locali contano. ova non spedisce i tuoi dati da nessuna parte — restano sul tuo disco. Quello che esporti è una tua decisione.

In conclusione

Per esportare i dati di uso di rete macOS, hai diversi percorsi ragionevoli: nettop -L per catture brevi, il log unificato per audit di eventi, script di campionamento custom per il pieno controllo, e un monitor locale supportato da SQLite come ova per accounting per app continuativo. Scegli in base al fatto se ti servono eventi o byte, e quanto è lunga la finestra che ti interessa.

Per un percorso a basso sforzo che cattura continuamente e ti permette di interrogare dopo, installa ova — circa 3 MB, macOS 14+, Apple Silicon e Intel, campiona a circa 1 Hz. I dati vivono nella tua directory ~/Library/Application Support/ova/ in SQLite, quindi qualsiasi strumento di analisi che già conosci può leggerli.