Log Rotation: hogyan működik, rotációs stratégiák és konfigurálás mobil projektekhez

Mi az a Log Rotation

A Log Rotation az aktív naplófájl időszakos cseréjének folyamata egy újra, a régi egyidejű archiválásával, tömörítésével vagy törlésével. Rotáció nélkül egyetlen naplófájl a végtelenségig nő, amíg meg nem tölti a teljes lemezpartíciót, ami az alkalmazás összeomlásához és adatvesztéshez vezet.

Tipikus forgatókönyv: az alkalmazás az app.log fájlba írja a naplókat. Amikor az app.log eléri a 100 MB-ot, a rendszer átnevezi app.log.1-re, tömöríti app.log.1.gz-be, és létrehoz egy új üres app.log fájlt. A következő telítődéskor az app.log.1 app.log.2 lesz, az app.log.1.gz app.log.2.gz lesz, a régi app.log.2.gz pedig törlődik. Ezt a mechanizmust keep count-os rotációnak nevezik — az archív másolatok száma rögzített.

A Splunk (2023) szerint a helytelen rotációs konfiguráció az alkalmazásszervereken a lemez megtelésével kapcsolatos incidensek 40%-ának oka. Mobileszközökön a rotáció még kritikusabb, mert a felhasználó nem tudja és nem is kell, hogy manuálisan kezelje a naplókat.

Naplórotációs stratégiák

A Log Rotation három alapstratégiát támogat, amelyek kombinálhatók. A stratégia kiválasztása az alkalmazás típusától függ: a szerverrendszerek gyakrabban használnak időalapú rotációt, a mobilalkalmazások — méretalapút, a beágyazott rendszerek — fájlszám alapút.

Méret alapú rotáció — a leggyakoribb

A méret alapú rotáció garantálja, hogy egyetlen naplófájl sem lépi túl a beállított határt. A határértéket a rendelkezésre álló lemezterület és a naplózás gyakorisága alapján választják ki. Szerver esetén a tipikus határ 100–500 MB fájlonként, mobileszköz esetén 1–10 MB. Ha az alkalmazás agresszívan naplóz, a határt csökkenteni kell, különben a rotáció néhány percenként megtörténik.

Idő alapú rotáció — megfelelőséghez

Az idő alapú rotáció független a naplók mennyiségétől — a fájl szigorúan az ütemezés szerint cserélődik. Azokhoz a rendszerekhez kényelmes, ahol a naplókat meghatározott számú napig kell tárolni: a napi rotáció keep count = 30 beállítással 30 napos tárolást jelent. Hátránya — egy fájl intenzív terhelés mellett akár gigabájtra is nőhet naponta.

logrotate Linuxban: konfiguráció és példák

A logrotate egy szabványos Linux segédprogram a naplók automatikus rotációjához. A cron indítja, és a /etc/logrotate.d/ könyvtárból dolgozza fel a konfigurációs fájlokat. Minden szolgáltatás (nginx, postgresql, alkalmazás) létrehozza a saját konfigját a naplók elérési útjával, a rotációs stratégiával és a rotáció utáni műveletekkel.

# /etc/logrotate.d/myapp — az alkalmazás naplóinak rotációja
/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
}

Ez a konfig napi rotációt végez, 7 archív másolatot őriz meg, a régi fájlokat gzip-pel tömöríti (kivéve az utolsót — delaycompress), nem ad hibát ha nincs napló (missingok), nem rotálja az üres fájlokat (notifempty), és a fájlt 0640 jogosultságokkal hozza létre újra. Rotáció után HUP jelet küld az alkalmazás folyamatának a postrotate szkripten keresztül.

logrotate paraméterek

size — rotáció a méret elérésekor (size 100M). rotate — archív másolatok száma (rotate 7). compress — gzip tömörítés. dateext — dátum hozzáadása a fájlnévhez sorszám helyett. sharedscripts — a postrotate egyszeri végrehajtása az összes fájlra, nem mindegyikre külön-külön. maxage — N napnál régebbi archívumok törlése.

Log Rotation mobileszközökön

Mobileszközökön a Log Rotation kritikus, mert a felhasználó nem kezeli a fájlrendszert, és nem várja el, hogy az alkalmazás gigabájtokat foglaljon naplókkal. Az iOS és Android beépített mechanizmusokkal rendelkezik: az iOS-en az os_log rögzített méretű körkörös puffert használ (rotáció felülírással), az Android Logcat korlátozott pufferrel rendelkezik a kernelben.

Egyéni fájlnaplókhoz iOS-en a CocoaLumberjack DDFileLogger osztálya használatos, amely támogatja a méret- és időalapú rotációt. Androidon — Logback vagy saját implementációk a RollingFileAppenderen keresztül. Mindkét eszköz lehetővé teszi a maximális fájlméret és az archívumok számának beállítását.

// CocoaLumberjack — fájl rotáció iOS-en
import CocoaLumberjack

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

iOS: az os_log nem igényel rotációt — az üzenetek felülíródnak a körkörös pufferben. De ha az alkalmazás egyéni fájlnaplókat ír (pl. hibakereséshez vagy szerverre küldéshez), a rotációt manuálisan kell konfigurálni. A CocoaLumberjack a szabványos választás az iOS csapatok számára, automatikusan tömöríti az archívumokat .gz formátumba, és törli a régi fájlokat a határ túllépésekor.

Miért fontos a rotáció Androidon

Android nem korlátozza az alkalmazást a naplók saját könyvtárba írásában. Ha a fejlesztő hibakeresési naplókat rotáció nélkül ír egy fájlba, egy hónapnyi aktív használat után 500 MB – 1 GB helyet foglalhatnak. A felhasználó akkor fedezi fel a problémát, amikor a rendszer helyhiányra figyelmeztet, és eltávolítja az alkalmazást. A Logback a RollingFileAppenderrel megoldja ezt a problémát: az 5 MB-os határ 3 archívummal garantálja, hogy a naplók soha nem foglalnak 20 MB-nál többet.

Rotáció megvalósítási példák iOS-en és Androidon

Az alábbiakban példák találhatók a naplórotáció konfigurálására mindkét platformon. iOS-en CocoaLumberjack, Androidon Logback XML konfigurációval.

// Logback Androidon — rotáció konfigurálása a logback.xml-ben
// Fájlméret 5MB, 3 archív másolat
@file:Suppress("unused")

// A logback.xml-ben:
// <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>

A CocoaLumberjack iOS-en nemcsak a méret alapú rotációt támogatja, hanem a régi naplók dátum szerinti törlését is a logFileManager.maximumLogFiles segítségével. Ha a maximumLogFiles = 0 értéket állítja be, a korlátozás megszűnik — a naplók a végtelenségig gyűlnek, ami veszélyes éles környezetben.

// Egyéni rotáció a teljes mennyiség ellenőrzésével
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 {
            // A legrégebbi fájlt töröljük
            files.sorted { $0.path < $1.path }.first.map {
                try? FileManager.default.removeItem(at: $0)
            }
        }
    }
}

Monitorozás és riasztások rotációkor

A Log Rotation nemcsak automatikus archiválás, hanem a rendszer egészségi állapotának jelzője is. Ha a naplók túl gyakran rotálódnak (néhány percenként), az túlzott naplózásra vagy hibák ciklikus naplózására (error log loop) utal. Állítson be riasztásokat a rotáció gyakoriságára: óránként 10-nél több rotáció — ok az ellenőrzésre.

Monitorozó rendszerek (Prometheus, Grafana, Datadog) a fájlrendszer exportőrein keresztül követhetik a rotációs metrikákat. A Prometheus node_exporter metrikákat szolgáltat a fájlok méretéről és módosítási idejéről. Mobileszközökön a rotáció monitorozása általában be van építve az SDK-ba: a CocoaLumberjack DDLog-on keresztül naplózza a rotációs eseményt, a Logback pedig az appenderen keresztül küldi az állapotot.

Riasztások: ha az archívumok száma meghaladja a vártat (a rotate count túllépte a határt) vagy a naplók teljes mennyisége meghaladta a kvótát — a rendszernek értesítenie kell a rendszergazdát. Szerverek esetén a standard küszöb a partíció 80%-a, mobileszközök esetén — riasztás az alkalmazásonkénti 50 MB túllépésekor.