日志轮转与归档

① 磁盘上限：任何单个日志目录都不应该无限增长
② 检索效率：正在写的文件越小，grep/tail 越快，出问题时越好查
③ 合规保留：某些日志必须留 N 天/N 年，删早了是事故

rename + reopen：
  mv app.log app.log.1        ← 旧 inode 被重命名
  kill -USR1 <pid>            ← 进程重新 open("app.log") 得到新 inode
  写入继续进入新文件，旧 inode 上不再有新数据

copytruncate：
  cp app.log app.log.1        ← 拷贝期间进程仍在写
  : > app.log                 ← 截断，拷贝窗口内的写入丢失

/etc/logrotate.conf          # 全局默认
/etc/logrotate.d/*           # 每个服务一个片段，按文件名字典序加载

# /etc/logrotate.conf 里的常见全局项
weekly                # 默认每周轮转
rotate 4              # 默认保留 4 份
create                # 轮转后创建新文件
dateext               # 用日期而非序号命名
compress              # 轮转后压缩
include /etc/logrotate.d

# /etc/logrotate.d/myapp
/var/log/myapp/*.log {
    daily
    rotate 14
    missingok
    notifempty
    compress
    delaycompress
    dateext
    dateformat -%Y%m%d
    create 0640 myapp myapp
    sharedscripts
    postrotate
        /bin/kill -USR1 $(cat /run/myapp.pid 2>/dev/null) 2>/dev/null || true
    endscript
}

# 关键点：kill 的目标 PID 必须能可靠取到
postrotate
    if [ -f /run/nginx.pid ]; then
        /bin/kill -USR1 "$(cat /run/nginx.pid)"
    fi
endscript

# 干跑：只打印将要做什么，不真的执行
logrotate -d /etc/logrotate.d/myapp

# 强制轮转一次（即使未到周期）
logrotate -f /etc/logrotate.d/myapp

# 指定状态文件（排查「为什么不轮转」时最有用）
logrotate -v -s /var/lib/logrotate/status /etc/logrotate.d/myapp

# 查看上次轮转时间
grep myapp /var/lib/logrotate/status

# /etc/systemd/system/logrotate.timer
[Timer]
OnCalendar=daily
Persistent=true          # 关机错过的执行会在开机后补跑

没有 delaycompress：
  mv app.log app.log.1
  gzip app.log.1            ← 立刻压缩
  进程若尚未重开 fd，仍指向 app.log.1 的 inode
  → 后续写入进入一个「正在被 gzip 读取」的文件，内容损坏

有 delaycompress：
  mv app.log app.log.1
  （本轮不压缩）
  下轮轮转时才 gzip app.log.1 → app.log.2.gz
  → 压缩时该文件已确认无写入

保留天数 ≈ 轮转周期 × rotate 份数
daily + rotate 14  → 约 14 天
weekly + rotate 8  → 约 8 周

# 精确计算某目录下日志的实际覆盖时间跨度
ls -1t /var/log/myapp/*.gz | tail -1 | xargs -r stat -c '%y %n'

# 每天一次：默认 dateformat 就够
dateext
dateformat -%Y%m%d          # app.log-20261007

# 一天可能轮转多次：必须加时分秒，否则命名冲突
dateformat -%Y%m%d-%H%M%S   # app.log-20261007-143022

# 轮转前先检查磁盘余量，余量不足时先删最旧的归档
check_space() {
    local dir=$1 need_mb=$2
    local avail_mb
    avail_mb=$(df -Pm "$dir" | awk 'NR==2 {print $4}')
    if [ "$avail_mb" -lt "$need_mb" ]; then
        echo "空间不足: 剩余 ${avail_mb}MB < 需要 ${need_mb}MB" >&2
        return 1
    fi
}

# 兜底清理：按时间删除超过 N 天的归档（独立于 logrotate）
find /var/log/myapp -name '*.gz' -mtime +30 -delete

#!/usr/bin/env bash
set -euo pipefail

BUCKET=s3://logs-archive/myapp
SRC=/var/log/myapp
RETENTION_DAYS=7

archive_one() {
    local f=$1
    local key="myapp/$(date -d "@$(stat -c %Y "$f")" +%Y/%m/%d)/$(basename "$f")"

    # 上传并记录 ETag，用于后续校验
    local etag
    etag=$(aws s3 cp "$f" "$BUCKET/$key" --only-show-errors \
            --metadata "sha256=$(sha256sum "$f" | cut -d' ' -f1)" \
            --query 'ETag' --output text) || return 1

    [ -n "$etag" ] || { echo "上传未返回 ETag: $f" >&2; return 1; }
    echo "已归档 $f → $key"
}

# 只归档超过保留期的压缩日志，避免动到正在写的文件
while IFS= read -r -d '' f; do
    archive_one "$f" && rm -f "$f"
done < <(find "$SRC" -name '*.gz' -mtime +"$RETENTION_DAYS" -print0)

{
  "Rules": [
    {
      "ID": "logs-tiering",
      "Filter": { "Prefix": "myapp/" },
      "Status": "Enabled",
      "Transitions": [
        { "Days": 30,  "StorageClass": "STANDARD_IA" },
        { "Days": 90,  "StorageClass": "GLACIER" }
      ],
      "Expiration": { "Days": 730 }
    }
  ]
}

# 应用生命周期配置
aws s3api put-bucket-lifecycle-configuration \
    --bucket logs-archive \
    --lifecycle-configuration file://lifecycle.json

# 大文件用分段上传，网络中断可续传
aws s3 cp big.log.gz "$BUCKET/$key" \
    --storage-class STANDARD_IA \
    --no-progress

# 配置自动分段阈值（默认 8MB）
aws configure set s3.multipart_threshold 64MB
aws configure set s3.multipart_chunksize 16MB

# 抽样验证远端对象可读且哈希一致
verify_archive() {
    local key=$1 expect=$2
    local tmp; tmp=$(mktemp)
    aws s3 cp "$BUCKET/$key" "$tmp" --only-show-errors
    local actual; actual=$(sha256sum "$tmp" | cut -d' ' -f1)
    rm -f "$tmp"
    [ "$actual" = "$expect" ] || { echo "校验失败: $key" >&2; return 1; }
}

1. 应用停止向旧 inode 写入（或至少不再打开新文件）
2. mv app.log app.log.1        ← 旧 inode 改名，应用 fd 仍指向它
3. kill -USR1 <pid>            ← 应用 close 旧 fd、open 新 app.log
4. 此时 app.log 是全新 inode，app.log.1 上无新写入
5. 压缩 app.log.1（delaycompress 下延后一轮）

cp app.log app.log.1     ← T1 开始拷贝，此刻文件内容为 A
（应用写入 B）            ← T2 应用写入，进入 app.log
: > app.log              ← T3 截断，B 永久丢失

# 1. 用 copytruncate 时保持单文件体积较小（配合 size 轮转）
size 50M
rotate 10
copytruncate

# 2. 写入侧尽量用 O_APPEND 且减少 flush 间隔
# 3. 关键日志改用 rename + reopen 模型

# 反例：应用写文件到容器内，日志随容器销毁而丢失
CMD ["./app", "--log-file", "/var/log/app.log"]

# 正例：写 stdout，由运行时接管轮转
CMD ["./app", "--log-stdout"]

# docker-compose 里配置 json-file 驱动的轮转
services:
  app:
    logging:
      driver: json-file
      options:
        max-size: "50m"
        max-file: "5"

#!/usr/bin/env bash
set -euo pipefail

# 简单可靠的按大小轮转，适合嵌入式与精简镜像
rotate_by_size() {
    local file=$1 max_bytes=$2 keep=$3

    [ -f "$file" ] || return 0
    local size; size=$(stat -c %s "$file")
    [ "$size" -lt "$max_bytes" ] && return 0

    local stamp; stamp=$(date +%Y%m%d-%H%M%S)
    cp "$file" "${file}.${stamp}"
    : > "$file"                      # 截断

    gzip -9 "${file}.${stamp}"

    # 按份数清理
    ls -1t "${file}".*.gz 2>/dev/null | tail -n +"$(( keep + 1 ))" | xargs -r rm -f
}

# 由应用在每次写日志前调用，或由 inotify 触发的独立进程调用