Log Rotation: paano ito gumagana, mga estratehiya ng rotasyon at configuration para sa mobile projects

Ano ang Log Rotation

Log Rotation ay ang proseso ng pana-panahong pagpapalit ng aktibong log file sa bago na may sabay na pag-archive, compression, o pagtanggal ng luma. Walang rotasyon, ang isang log file ay lumalaki nang walang hanggan hanggang mapuno nito ang buong disk partition, na humahantong sa pag-crash ng app at pagkawala ng data.

Karaniwang scenario: ang app ay nagsusulat ng log sa file na app.log. Kapag ang app.log ay umabot sa 100 MB, ang system ay nagre-rename nito sa app.log.1, kino-compress sa app.log.1.gz, at gumagawa ng bagong walang laman na app.log. Sa susunod na pagpuno, ang app.log.1 ay nagiging app.log.2, ang app.log.1.gz ay nagiging app.log.2.gz, at ang lumang app.log.2.gz ay tinatanggal. Ang mekanismong ito ay tinatawag na rotasyon na may keep count — ang bilang ng archive copies ay fixed.

Ayon sa Splunk (2023), ang maling configuration ng rotasyon ay sanhi ng 40% ng mga insidenteng may kaugnayan sa pagpuno ng disk sa mga app server. Para sa mga mobile device, ang rotasyon ay mas kritikal dahil ang user ay hindi maaari at hindi dapat mag-manage ng log nang manu-mano.

Mga estratehiya ng rotasyon ng log

Log Rotation ay sumusuporta sa tatlong basic na estratehiya na maaaring pagsamahin. Ang pagpili ng estratehiya ay depende sa uri ng app: ang mga server system ay mas madalas gumagamit ng rotasyon batay sa oras, mobile app — batay sa laki, embedded system — batay sa bilang ng mga file.

Rotasyon batay sa laki — ang pinakakaraniwan

Rotasyon batay sa laki ay ginagarantiya na walang log file ang lumalampas sa itinakdang limit. Ang limit ay pinipili batay sa available na disk space at frequency ng logging. Para sa server, ang typical na limit ay 100–500 MB bawat file, para sa mobile device — 1–10 MB. Kung ang app ay nagla-log nang agresibo, ang limit ay dapat ibaba, kung hindi ang rotasyon ay magaganap bawat ilang minuto.

Rotasyon batay sa oras — para sa compliance

Rotasyon batay sa oras ay independyente sa volume ng log — ang file ay nagbabago nang mahigpit ayon sa schedule. Maginhawa para sa mga system kung saan ang log ay dapat itago sa fixed na bilang ng araw: araw-araw na rotasyon na may keep count = 30 ay nangangahulugang 30 araw na pag-iimbak. Disadvantage — ang isang file ay maaaring lumaki hanggang isang gigabyte bawat araw sa ilalim ng intensive load.

logrotate sa Linux: configuration at mga halimbawa

logrotate ay ang standard na Linux utility para sa awtomatikong rotasyon ng log. Ito ay pinapatakbo sa pamamagitan ng cron at nagpo-proseso ng configuration file mula sa /etc/logrotate.d/. Bawat serbisyo (nginx, postgresql, app) ay gumagawa ng sarili nitong config na may mga path sa log, estratehiya ng rotasyon, at mga aksyon pagkatapos ng rotasyon.

# /etc/logrotate.d/myapp — rotasyon ng log ng app
/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
}

Ang config na ito ay nag-ro-rotate ng log araw-araw, nag-iimbak ng 7 archive copies, nagco-compress ng lumang file gamit ang gzip (maliban sa huli — delaycompress), hindi nagbibigay ng error kung walang log (missingok), hindi nagro-rotate ng empty file (notifempty), at muling gumagawa ng file na may permissions na 0640. Pagkatapos ng rotasyon, nagpapadala ng HUP signal sa process ng app sa pamamagitan ng postrotate script.

Mga parameter ng logrotate

size — rotasyon kapag naabot ang laki (size 100M). rotate — bilang ng archive copies (rotate 7). compress — gzip compression. dateext — pagdagdag ng date sa filename sa halip na sequential number. sharedscripts — pag-execute ng postrotate nang isang beses para sa lahat ng file, hindi para sa bawat isa nang hiwalay. maxage — pagtanggal ng archive na mas matanda sa N araw.

Log Rotation sa mga mobile app

Sa mga mobile device, ang Log Rotation ay kritikal dahil ang user ay hindi nagma-manage ng file system at hindi inaasahan na ang app ay kukuha ng gigabytes para sa log. Ang iOS at Android ay may built-in na mekanismo: ang os_log sa iOS ay gumagamit ng circular buffer na may fixed size (rotasyon sa pamamagitan ng overwrite), ang Android Logcat ay may limitadong buffer sa kernel.

Para sa custom na file log sa iOS, ginagamit ang CocoaLumberjack na may class na DDFileLogger, na sumusuporta sa rotasyon batay sa laki at oras. Sa Android — Logback o sariling implementasyon sa pamamagitan ng RollingFileAppender. Ang parehong tool ay nagpapahintulot na itakda ang maximum na laki ng file at bilang ng archive.

// CocoaLumberjack — file rotasyon sa iOS
import CocoaLumberjack

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

iOS: ang os_log ay hindi nangangailangan ng rotasyon — ang mga mensahe ay na-o-overwrite sa circular buffer. Ngunit kung ang app ay nagsusulat ng custom na file log (halimbawa, para sa debugging o pagpapadala sa server), ang rotasyon ay dapat i-configure nang manu-mano. Ang CocoaLumberjack ay ang standard na pagpipilian para sa iOS teams, awtomatiko itong nagco-compress ng archive sa .gz at nagtatanggal ng lumang file kapag lumampas sa limit.

Bakit mahalaga ang rotasyon sa Android

Android ay hindi nagli-limit sa app sa pagsusulat ng log sa sarili nitong directory. Kung ang developer ay nagsusulat ng debug log sa file na walang rotasyon, sa loob ng isang buwan ng aktibong paggamit ay maaaring umabot ng 500 MB — 1 GB. Ang user ay makakatuklas ng problema kapag ang system ay nagpakita ng babala ng hindi sapat na espasyo at tatanggalin ang app. Ang Logback na may RollingFileAppender ay lumulutas ng problemang ito: limit na 5 MB na may 3 archive ay ginagarantiya na ang log ay hindi kailanman kukuha ng higit sa 20 MB.

Mga halimbawa ng implementasyon ng rotasyon sa iOS at Android

Sa ibaba ay mga halimbawa ng configuration ng log rotasyon sa parehong platform. Sa iOS ay ginagamit ang CocoaLumberjack, sa Android — Logback na may configuration sa pamamagitan ng XML.

// Logback sa Android — configuration ng rotasyon sa logback.xml
// Laki ng file 5MB, 3 archive copies
@file:Suppress("unused")

// Sa 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 sa iOS ay sumusuporta hindi lamang rotasyon batay sa laki, kundi pati na rin pagtanggal ng lumang log batay sa date gamit ang logFileManager.maximumLogFiles. Kung itatakda mo ang maximumLogFiles = 0, ang limitasyon ay aalisin — ang log ay maipon nang walang hanggan, na delikado para sa production.

// Custom rotasyon na may checking ng kabuuang volume
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 {
            // Tinatanggal namin ang pinakamatandang file
            files.sorted { $0.path < $1.path }.first.map {
                try? FileManager.default.removeItem(at: $0)
            }
        }
    }
}

Monitoring at alerto sa rotasyon

Ang Log Rotation ay hindi lamang awtomatikong pag-archive, kundi pati na rin indicator ng kalusugan ng system. Kung ang log ay masyadong madalas mag-rotate (bawat ilang minuto), ito ay senyales ng sobrang logging o error sa cyclic error logging (error log loop). I-configure ang mga alerto sa frequency ng rotasyon: higit sa 10 rotasyon bawat oras — dahilan para suriin.

Mga monitoring system (Prometheus, Grafana, Datadog) ay maaaring subaybayan ang metrics ng rotasyon sa pamamagitan ng file system exporters. Ang Prometheus node_exporter ay nagbibigay ng metrics ng laki ng file at oras ng pagbabago nito. Sa mga mobile device, ang rotasyon monitoring ay karaniwang naka-built in sa SDK: ang CocoaLumberjack ay nagla-log ng rotasyon event sa pamamagitan ng DDLog, at ang Logback ay nagpapadala ng status sa pamamagitan ng appender.

Alerto: kung ang archive ay mas marami kaysa inaasahan (rotate count ay lumampas sa limit) o ang kabuuang volume ng log ay lumampas sa quota — ang system ay dapat mag-notify sa administrator. Para sa mga server, ang standard threshold ay 80% ng laki ng partition, para sa mga mobile device — alerto kapag lumampas sa 50 MB bawat app.