Log Rotation: jak to funguje, strategie rotace a konfigurace pro mobilní projekty

Co je Log Rotation

Log Rotation je proces periodické změny aktivního log souboru na nový s archivací, kompresí nebo odstraněním starého. Bez rotace jeden log soubor roste donekonečna, dokud nezaplní celý diskový oddíl, což vede k selhání aplikace a ztrátě dat.

Typický scénář: aplikace zapisuje logy do souboru app.log. Když app.log dosáhne 100 MB, systém jej přejmenuje na app.log.1, zkomprimuje na app.log.1.gz a vytvoří nový prázdný app.log. Při dalším zaplnění se app.log.1 stane app.log.2, app.log.1.gz se stane app.log.2.gz a starý app.log.2.gz se odstraní. Tento mechanismus se nazývá rotace s keep count — počet archivních kopií je pevný.

Podle Splunk (2023) je nesprávná konfigurace rotace příčinou 40% incidentů souvisejících s plným diskem na aplikačních serverech. Pro mobilní zařízení je rotace ještě kritičtější, protože uživatel nemůže a nemá ručně spravovat logy.

Strategie rotace logů

Log Rotation podporuje tři základní strategie, které lze kombinovat. Volba strategie závisí na typu aplikace: serverové systémy častěji používají rotaci podle času, mobilní aplikace — podle velikosti, vestavěné systémy — podle počtu souborů.

Rotace podle velikosti — nejrozšířenější

Rotace podle velikosti zaručuje, že žádný log soubor nepřekročí stanovený limit. Limit se volí na základě dostupného diskového prostoru a frekvence logování. Pro server je typický limit 100–500 MB na soubor, pro mobilní zařízení 1–10 MB. Pokud aplikace loguje agresivně, je třeba limit snížit, jinak bude rotace probíhat každých několik minut.

Rotace podle času — pro shodu

Rotace podle času je nezávislá na objemu logů — soubor se mění striktně podle plánu. Vhodná pro systémy, kde musí být logy uchovávány pevný počet dní: denní rotace s keep count = 30 znamená 30 dní uchovávání. Nevýhoda — jeden soubor může při intenzivní zátěži narůst až na gigabajt denně.

logrotate v Linuxu: konfigurace a příklady

logrotate je standardní nástroj Linuxu pro automatickou rotaci logů. Spouští se přes cron a zpracovává konfigurační soubory z /etc/logrotate.d/. Každá služba (nginx, postgresql, aplikace) vytváří vlastní konfig s cestami k logům, strategií rotace a akcemi po rotaci.

# /etc/logrotate.d/myapp — rotace logů aplikace
/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
}

Tento konfig rotuje logy denně, uchovává 7 archivních kopií, komprimuje staré soubory gzipem (kromě posledního — delaycompress), nehlásí chybu pokud logy neexistují (missingok), nerotuje prázdné soubory (notifempty) a znovu vytváří soubor s právy 0640. Po rotaci odesílá HUP signál procesu aplikace pomocí postrotate skriptu.

Parametry logrotate

size — rotace po dosažení velikosti (size 100M). rotate — počet archivních kopií (rotate 7). compress — komprese gzip. dateext — přidání data do názvu souboru místo pořadového čísla. sharedscripts — provedení postrotate jednou pro všechny soubory, ne pro každý zvlášť. maxage — odstranění archivů starších než N dní.

Log Rotation v mobilních aplikacích

Na mobilních zařízeních je Log Rotation kritická, protože uživatel nespravuje souborový systém a neočekává, že aplikace zabere gigabajty logy. iOS a Android mají vestavěné mechanismy: os_log na iOS používá kruhový buffer pevné velikosti (rotace přepisováním), Android Logcat má omezený buffer v jádře.

Pro vlastní souborové logy na iOS se používá CocoaLumberjack s třídou DDFileLogger, který podporuje rotaci podle velikosti a času. Na Androidu — Logback nebo vlastní implementace přes RollingFileAppender. Oba nástroje umožňují nastavit maximální velikost souboru a počet archivů.

// CocoaLumberjack — souborová rotace na iOS
import CocoaLumberjack

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

iOS: os_log nevyžaduje rotaci — zprávy se přepisují v kruhovém bufferu. Pokud však aplikace zapisuje vlastní souborové logy (např. pro ladění nebo odesílání na server), je třeba rotaci nakonfigurovat ručně. CocoaLumberjack je standardní volbou pro iOS týmy, automaticky komprimuje archivy do .gz a odstraňuje staré soubory při překročení limitu.

Proč je rotace důležitá na Androidu

Android neomezuje aplikaci v zápisu logů do vlastního adresáře. Pokud vývojář zapisuje debug logy do souboru bez rotace, za měsíc aktivního používání mohou zabrat 500 MB — 1 GB. Uživatel objeví problém, když systém zobrazí varování o nedostatku místa, a aplikaci odstraní. Logback s RollingFileAppender tento problém řeší: limit 5 MB se 3 archivy zaručuje, že logy nikdy nezaberou více než 20 MB.

Příklady implementace rotace na iOS a Androidu

Níže jsou uvedeny příklady konfigurace rotace logů na obou platformách. Na iOS se používá CocoaLumberjack, na Androidu — Logback s konfigurací přes XML.

// Logback na Androidu — konfigurace rotace v logback.xml
// Velikost souboru 5MB, 3 archivní kopie
@file:Suppress("unused")

// V 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 na iOS podporuje nejen rotaci podle velikosti, ale také mazání starých logů podle data pomocí logFileManager.maximumLogFiles. Pokud nastavíte maximumLogFiles = 0, omezení se odstraní — logy se budou donekonečna hromadit, což je pro produkci nebezpečné.

// Vlastní rotace s kontrolou celkového objemu
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 {
            // Odstraňujeme nejstarší soubor
            files.sorted { $0.path < $1.path }.first.map {
                try? FileManager.default.removeItem(at: $0)
            }
        }
    }
}

Monitoring a alerty při rotaci

Log Rotation není jen automatická archivace, ale také indikátor zdraví systému. Pokud se logy rotují příliš často (každých několik minut), je to signál nadměrného logování nebo chyby v cyklickém logování chyb (error log loop). Nastavte alerty na frekvenci rotace: více než 10 rotací za hodinu — důvod ke kontrole.

Monitorovací systémy (Prometheus, Grafana, Datadog) mohou sledovat metriky rotace pomocí exportérů souborového systému. Prometheus node_exporter poskytuje metriky velikosti souborů a času jejich úpravy. Na mobilních zařízeních je monitoring rotace obvykle integrován do SDK: CocoaLumberjack loguje událost rotace přes DDLog, Logback odesílá stav přes appender.

Alergy: pokud je archivů více, než se očekávalo (rotate count překročil limit), nebo celkový objem logů překročil kvótu — systém by měl informovat administrátora. Pro servery je standardní práh 80% velikosti oddílu, pro mobilní zařízení — alert při překročení 50 MB na aplikaci.