Log Rotation: come funziona, strategie di rotazione e configurazione per progetti mobile

Cos'è Log Rotation

Log Rotation è il processo di cambio periodico del file di log attivo con uno nuovo, archiviando, comprimendo o eliminando contemporaneamente il vecchio. Senza rotazione, un singolo file di log cresce indefinitamente fino a riempire l'intera partizione del disco, causando il fallimento dell'applicazione e la perdita di dati.

Scenario tipico: un'applicazione scrive log nel file app.log. Quando app.log raggiunge 100 MB, il sistema lo rinomina in app.log.1, lo comprime in app.log.1.gz e crea un nuovo app.log vuoto. Al successivo riempimento, app.log.1 diventa app.log.2, app.log.1.gz diventa app.log.2.gz e il vecchio app.log.2.gz viene eliminato. Questo meccanismo si chiama rotazione con keep count — il numero di copie d'archivio è fisso.

Secondo Splunk (2023), una configurazione errata della rotazione è la causa del 40% degli incidenti legati all'esaurimento dello spazio su disco sui server applicativi. Per i dispositivi mobili, la rotazione è ancora più critica perché l'utente non può e non deve gestire i log manualmente.

Strategie di rotazione dei log

Log Rotation supporta tre strategie di base che possono essere combinate. La scelta della strategia dipende dal tipo di applicazione: i sistemi server usano più spesso la rotazione per tempo, i mobile — per dimensione, i sistemi embedded — per numero di file.

Rotazione per dimensione — la più comune

La rotazione per dimensione garantisce che nessun file di log superi un limite prestabilito. Il limite viene scelto in base allo spazio su disco disponibile e alla frequenza di registrazione. Per un server, il limite tipico è di 100–500 MB per file, per un dispositivo mobile — di 1–10 MB. Se l'applicazione registra in modo aggressivo, il limite deve essere ridotto, altrimenti la rotazione avverrà ogni pochi minuti.

Rotazione per tempo — per conformità

La rotazione per tempo è indipendente dal volume dei log — il file viene cambiato rigorosamente secondo un programma. Comoda per i sistemi in cui i log devono essere conservati per un numero fisso di giorni: rotazione giornaliera con keep count = 30 significa 30 giorni di conservazione. Lo svantaggio — un singolo file può raggiungere un gigabyte al giorno sotto carico intensivo.

logrotate su Linux: configurazione ed esempi

logrotate è l'utilità standard Linux per la rotazione automatica dei log. Viene eseguita tramite cron e processa i file di configurazione da /etc/logrotate.d/. Ogni servizio (nginx, postgresql, applicazione) crea la propria configurazione specificando i percorsi dei log, la strategia di rotazione e le azioni post-rotazione.

# /etc/logrotate.d/myapp — rotazione dei log dell'applicazione
/var/log/myapp/*.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
    create 0640 www-data www-data
    postrotate
        kill -HUP $(cat /var/run/myapp.pid)
    endscript
}

Questa configurazione ruota i log quotidianamente, conserva 7 copie d'archivio, comprime i file vecchi con gzip (eccetto l'ultimo — delaycompress), non genera errore se i log sono assenti (missingok), non ruota i file vuoti (notifempty) e ricrea il file con permessi 0640. Dopo la rotazione, invia un segnale HUP al processo dell'applicazione tramite uno script postrotate.

Parametri di logrotate

size — rotazione al raggiungimento di una dimensione (size 100M). rotate — numero di copie d'archivio (rotate 7). compress — compressione gzip. dateext — aggiunge la data al nome del file anziché un numero sequenziale. sharedscripts — esegue postrotate una volta per tutti i file, non per ciascuno individualmente. maxage — elimina gli archivi più vecchi di N giorni.

Log Rotation nelle applicazioni mobili

Sui dispositivi mobili, Log Rotation è critica perché l'utente non gestisce il filesystem e non si aspetta che l'applicazione occupi gigabyte con i log. iOS e Android hanno meccanismi integrati: os_log su iOS utilizza un buffer circolare di dimensione fissa (rotazione per sovrascrittura), Android Logcat ha un buffer limitato nel kernel.

Per log di file personalizzati su iOS si usa CocoaLumberjack con la classe DDFileLogger, che supporta la rotazione per dimensione e per tempo. Su Android — Logback o implementazioni personalizzate tramite RollingFileAppender. Entrambi gli strumenti consentono di impostare la dimensione massima del file e il numero di archivi.

// CocoaLumberjack — rotazione file su iOS
import CocoaLumberjack

let fileLogger = DDFileLogger()
fileLogger.maximumFileSize = 1024 * 1024 // 1 MB
fileLogger.logFileManager.maximumNumberOfLogFiles = 5
DDLog.add(fileLogger)

iOS: os_log non richiede rotazione — i messaggi vengono sovrascritti nel buffer circolare. Ma se l'applicazione scrive log di file personalizzati (per debug o invio al server), la rotazione deve essere configurata manualmente. CocoaLumberjack è la scelta standard per i team iOS — comprime automaticamente gli archivi in .gz ed elimina i file vecchi quando il limite viene superato.

Perché la rotazione è importante su Android

Android non limita le applicazioni nello scrivere log nella propria directory. Se uno sviluppatore scrive log di debug in un file senza rotazione, in un mese di utilizzo attivo possono occupare da 500 MB a 1 GB. L'utente scoprirà il problema quando il sistema mostrerà un avviso di spazio insufficiente ed eliminerà l'app. Logback con RollingFileAppender risolve questo problema: un limite di 5 MB con 3 archivi garantisce che i log non superino mai i 20 MB.

Esempi di implementazione della rotazione su iOS e Android

Di seguito sono riportati esempi di configurazione della rotazione dei log su entrambe le piattaforme. Su iOS si usa CocoaLumberjack, su Android — Logback con configurazione XML.

// Logback su Android — configurazione della rotazione in logback.xml
// Dimensione file 5MB, 3 copie d'archivio
@file:Suppress("unused")

// In logback.xml:
// <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
//   <file>${DATA_DIR}/logs/app.log</file>
//   <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
//     <fileNamePattern>app.%i.log.gz</fileNamePattern>
//     <minIndex>1</minIndex>
//     <maxIndex>3</maxIndex>
//   </rollingPolicy>
//   <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
//     <maxFileSize>5MB</maxFileSize>
//   </triggeringPolicy>
// </appender>

CocoaLumberjack su iOS supporta non solo la rotazione per dimensione ma anche l'eliminazione dei log vecchi per data utilizzando logFileManager.maximumLogFiles. Se si imposta maximumLogFiles = 0, il limite viene rimosso — i log si accumuleranno indefinitamente, il che è pericoloso per la produzione.

// Rotazione personalizzata con controllo del volume totale
class SizeAwareLogger {
    let maxTotalSize: Int64 = 20 * 1024 * 1024

    func enforceQuota(at logDirectory: URL) {
        let files = (try? FileManager.default
            .contentsOfDirectory(
                at: logDirectory,
                includingPropertiesForKeys: [.fileSize]
            )) ?? []
        let total = files.reduce(0) {
            $0 + (try? $1.resourceValues(forKeys: [.fileSize])
                .fileSize).map(Int64.init) ?? 0
        }
        if total > maxTotalSize {
            // Elimina il file più vecchio
            files.sorted { $0.path < $1.path }.first.map {
                try? FileManager.default.removeItem(at: $0)
            }
        }
    }
}

Monitoraggio e allerte durante la rotazione

Log Rotation non è solo archiviazione automatica ma anche un indicatore di salute del sistema. Se i log ruotano troppo frequentemente (ogni pochi minuti), segnala una registrazione eccessiva o un ciclo di registrazione errori. Imposta allerte sulla frequenza di rotazione: più di 10 rotazioni all'ora sono motivo di verifica.

I sistemi di monitoraggio (Prometheus, Grafana, Datadog) possono tracciare le metriche di rotazione attraverso esportatori del filesystem. Prometheus node_exporter fornisce metriche sulla dimensione dei file e sul tempo di modifica. Sui dispositivi mobili, il monitoraggio della rotazione è solitamente integrato nell'SDK: CocoaLumberjack registra l'evento di rotazione tramite DDLog e Logback invia lo stato tramite un appender.

Allerte: se ci sono più archivi del previsto (il conteggio di rotazione ha superato il limite) o il volume totale dei log ha superato la quota — il sistema deve notificare l'amministratore. Per i server, la soglia standard è l'80% della dimensione della partizione; per i dispositivi mobili — un'allerta quando vengono superati i 50 MB per applicazione.