# Linux logrotate 설정 예시
/var/log/myapp/*.log {
    daily                # 매일 로테이션
    rotate 30            # 30개 파일 유지
    compress             # 압축 저장
    delaycompress        # 최신 파일은 압축 안 함
    missingok            # 파일 없어도 에러 안 냄
    notifempty           # 빈 파일은 로테이션 안 함
    create 0644 www-data www-data
}

// 전통적인 방식 (분석하기 어려움)
2024-01-15 10:30:45 User login failed: admin from 192.168.1.100

// 구조화된 방식 (분석하기 쉬움)
{
  "timestamp": "2024-01-15T10:30:45Z",
  "level": "WARN",
  "event": "login_failed",
  "user": "admin",
  "ip": "192.168.1.100",
  "reason": "invalid_password"
}

-- MySQL 예시: 오래된 주문 데이터를 아카이브 테이블로 이동
CREATE TABLE orders_archive LIKE orders;

INSERT INTO orders_archive 
SELECT * FROM orders 
WHERE order_date < DATE_SUB(NOW(), INTERVAL 1 YEAR);

DELETE FROM orders 
WHERE order_date < DATE_SUB(NOW(), INTERVAL 1 YEAR);

-- PostgreSQL 파티셔닝 예시
CREATE TABLE logs (
    id SERIAL,
    log_date DATE NOT NULL,
    message TEXT
) PARTITION BY RANGE (log_date);

-- 월별 파티션 생성
CREATE TABLE logs_2024_01 PARTITION OF logs
    FOR VALUES FROM ('2024-01-01') TO ('2024-02-01');

CREATE TABLE logs_2024_02 PARTITION OF logs
    FOR VALUES FROM ('2024-02-01') TO ('2024-03-01');

// Node.js 예시
async function archiveOldOrders() {
    const oneYearAgo = new Date();
    oneYearAgo.setFullYear(oneYearAgo.getFullYear() - 1);
    
    // 오래된 주문 조회
    const oldOrders = await db.orders.find({
        order_date: { $lt: oneYearAgo }
    });
    
    // S3에 JSON 파일로 저장
    const archiveData = JSON.stringify(oldOrders);
    await s3.putObject({
        Bucket: 'order-archives',
        Key: `orders-${Date.now()}.json.gz`,
        Body: gzip(archiveData)
    });
    
    // 원본 데이터 삭제
    await db.orders.deleteMany({
        order_date: { $lt: oneYearAgo }
    });
}

# 매일 새벽 2시에 아카이빙 스크립트 실행
0 2 * * * /usr/local/bin/archive_old_data.sh >> /var/log/archive.log 2>&1

# 매주 일요일 새벽 3시에 로그 정리
0 3 * * 0 /usr/local/bin/cleanup_logs.sh

#!/bin/bash
# 아카이빙 모니터링 스크립트

# 디스크 사용량 체크
DISK_USAGE=$(df -h /var/lib/mysql | awk 'NR==2 {print $5}' | sed 's/%//')

if [ $DISK_USAGE -gt 80 ]; then
    echo "경고: 디스크 사용량이 ${DISK_USAGE}%입니다!" | \
    mail -s "디스크 용량 경고" admin@example.com
fi

# 아카이브 파일 개수 체크
ARCHIVE_COUNT=$(ls -1 /archives/*.gz | wc -l)
echo "현재 아카이브 파일 개수: $ARCHIVE_COUNT"

# 최근 아카이빙 작업 확인
LAST_ARCHIVE=$(ls -t /archives/*.gz | head -1)
echo "최근 아카이브: $LAST_ARCHIVE"

# logstash.conf
input {
  # 파일에서 로그 읽기
  file {
    path => "/var/log/nginx/access.log"
    start_position => "beginning"
    type => "nginx"
  }
  
  # TCP로 로그 받기
  tcp {
    port => 5000
    type => "app"
  }
}

filter {
  # nginx 로그 파싱
  if [type] == "nginx" {
    grok {
      match => { "message" => "%{COMBINEDAPACHELOG}" }
    }
    date {
      match => [ "timestamp", "dd/MMM/yyyy:HH:mm:ss Z" ]
    }
  }
  
  # JSON 로그 파싱
  if [type] == "app" {
    json {
      source => "message"
    }
  }
}

output {
  # Elasticsearch로 전송
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "logs-%{+YYYY.MM.dd}"
  }
  
  # 콘솔에도 출력 (디버깅용)
  stdout {
    codec => rubydebug
  }
}

# fluent.conf
<source>
  @type tail
  path /var/log/nginx/access.log
  pos_file /var/log/td-agent/nginx.pos
  tag nginx.access
  <parse>
    @type nginx
  </parse>
</source>

<filter nginx.access>
  @type record_transformer
  <record>
    hostname ${hostname}
    service nginx
  </record>
</filter>

<match nginx.access>
  @type elasticsearch
  host localhost
  port 9200
  logstash_format true
  logstash_prefix nginx
</match>

// 좋은 로그 예시
{
  "timestamp": "2024-01-15T10:30:45.123Z",
  "level": "ERROR",
  "request_id": "req-abc123",
  "user_id": "user-456",
  "ip": "192.168.1.100",
  "server": "web-server-01",
  "service": "payment",
  "message": "결제 처리 실패",
  "error": "카드 승인 거부",
  "amount": 50000,
  "card_last4": "1234"
}

// 민감 정보 마스킹 함수
function maskSensitiveData(data) {
  const masked = { ...data };
  
  // 비밀번호 마스킹
  if (masked.password) {
    masked.password = '***';
  }
  
  // 카드번호 마스킹 (마지막 4자리만 표시)
  if (masked.card_number) {
    masked.card_number = 
      masked.card_number.slice(-4).padStart(16, '*');
  }
  
  // 이메일 마스킹
  if (masked.email) {
    const [name, domain] = masked.email.split('@');
    masked.email = name[0] + '***@' + domain;
  }
  
  return masked;
}

// 사용 예시
logger.info('사용자 로그인', maskSensitiveData({
  email: 'user@example.com',
  password: 'secret123',
  card_number: '1234567812345678'
}));

// 출력: { email: 'u***@example.com', password: '***', card_number: '************5678' }

// Elasticsearch Watcher 설정
PUT _watcher/watch/error_alert
{
  "trigger": {
    "schedule": {
      "interval": "5m"  // 5분마다 체크
    }
  },
  "input": {
    "search": {
      "request": {
        "indices": ["logs-*"],
        "body": {
          "query": {
            "bool": {
              "must": [
                { "match": { "level": "ERROR" }},
                { "range": { "@timestamp": { "gte": "now-5m" }}}
              ]
            }
          }
        }
      }
    }
  },
  "condition": {
    "compare": {
      "ctx.payload.hits.total": {
        "gt": 10  // 5분간 에러가 10건 이상이면
      }
    }
  },
  "actions": {
    "send_slack": {
      "webhook": {
        "url": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
        "body": "에러 급증 감지! 최근 5분간 {{ctx.payload.hits.total}}건의 에러 발생"
      }
    }
  }
}

-- 주문 테이블을 연도별로 Range 파티셔닝
CREATE TABLE orders (
    order_id BIGSERIAL,
    order_date DATE NOT NULL,
    region VARCHAR(50),
    amount DECIMAL(10,2)
) PARTITION BY RANGE (order_date);

-- 2024년 파티션 생성 (지역별로 서브파티셔닝)
CREATE TABLE orders_2024 PARTITION OF orders
    FOR VALUES FROM ('2024-01-01') TO ('2025-01-01')
    PARTITION BY LIST (region);

-- 지역별 서브파티션
CREATE TABLE orders_2024_seoul PARTITION OF orders_2024
    FOR VALUES IN ('서울', '경기');

CREATE TABLE orders_2024_busan PARTITION OF orders_2024
    FOR VALUES IN ('부산', '경남');

-- 인덱스는 자동으로 각 파티션에 생성됨
CREATE INDEX ON orders (order_date);
CREATE INDEX ON orders (region);

#!/bin/bash
# 7일 이상 된 로그 파일 압축

LOG_DIR="/var/log/myapp"
ARCHIVE_DIR="/archives/logs"

# 7일 이상 된 .log 파일 찾기
find $LOG_DIR -name "*.log" -mtime +7 | while read logfile; do
    # 파일명에서 날짜 추출
    filename=$(basename "$logfile")
    
    # zstd로 압축 (레벨 19 = 최대 압축)
    zstd -19 "$logfile" -o "$ARCHIVE_DIR/${filename}.zst"
    
    # 압축 성공하면 원본 삭제
    if [ $? -eq 0 ]; then
        rm "$logfile"
        echo "압축 완료: $filename"
    fi
done

# 1년 이상 된 압축 파일은 S3로 이동
find $ARCHIVE_DIR -name "*.zst" -mtime +365 | while read archive; do
    aws s3 cp "$archive" s3://my-log-archive/
    rm "$archive"
done

-- 나쁜 예: 모든 컬럼에 인덱스
CREATE INDEX idx_user_name ON users(name);
CREATE INDEX idx_user_email ON users(email);
CREATE INDEX idx_user_phone ON users(phone);
CREATE INDEX idx_user_address ON users(address);
-- 너무 많아! 😱

-- 좋은 예: 실제 쿼리 패턴에 맞춘 인덱스
-- 이메일로 자주 검색
CREATE UNIQUE INDEX idx_user_email ON users(email);

-- 이름과 생성일로 자주 검색
CREATE INDEX idx_user_name_created ON users(name, created_at);

-- 활성 사용자만 필터링 (부분 인덱스)
CREATE INDEX idx_active_users ON users(last_login) 
WHERE status = 'active';

// Node.js 암호화 예시
const crypto = require('crypto');

class DataEncryption {
  constructor(secretKey) {
    this.algorithm = 'aes-256-gcm';
    this.key = crypto.scryptSync(secretKey, 'salt', 32);
  }
  
  // 데이터 암호화
  encrypt(text) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv(this.algorithm, this.key, iv);
    
    let encrypted = cipher.update(text, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    
    const authTag = cipher.getAuthTag();
    
    return {
      encrypted,
      iv: iv.toString('hex'),
      authTag: authTag.toString('hex')
    };
  }
  
  // 데이터 복호화
  decrypt(encrypted, iv, authTag) {
    const decipher = crypto.createDecipheriv(
      this.algorithm,
      this.key,
      Buffer.from(iv, 'hex')
    );
    
    decipher.setAuthTag(Buffer.from(authTag, 'hex'));
    
    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    
    return decrypted;
  }
}

// 사용 예시
const encryptor = new DataEncryption(process.env.ENCRYPTION_KEY);

// 민감 정보 암호화
const userData = {
  name: '홍길동',
  ssn: '123456-1234567',
  card: '1234-5678-9012-3456'
};

const encrypted = encryptor.encrypt(JSON.stringify(userData));

// DB에 저장
await db.users.insert({
  user_id: 'user123',
  encrypted_data: encrypted.encrypted,
  iv: encrypted.iv,
  auth_tag: encrypted.authTag
});

// 복호화
const decrypted = encryptor.decrypt(
  encrypted.encrypted,
  encrypted.iv,
  encrypted.authTag
);
console.log(JSON.parse(decrypted)); // 원본 데이터

// 감사 로그 미들웨어 예시
function auditLogger(req, res, next) {
  const startTime = Date.now();
  
  // 응답 완료 후 로그 기록
  res.on('finish', async () => {
    const auditLog = {
      timestamp: new Date().toISOString(),
      user_id: req.user?.id || 'anonymous',
      ip_address: req.ip,
      method: req.method,
      path: req.path,
      query: req.query,
      status_code: res.statusCode,
      duration_ms: Date.now() - startTime,
      user_agent: req.get('user-agent'),
      request_id: req.id
    };
    
    // 민감한 작업은 상세 로그
    if (['POST', 'PUT', 'DELETE'].includes(req.method)) {
      auditLog.body = maskSensitiveData(req.body);
    }
    
    // 감사 로그 저장 (별도 테이블)
    await db.audit_logs.insert(auditLog);
    
    // 중요 작업은 알림
    if (req.path.includes('/admin') && res.statusCode === 200) {
      await sendAlert('관리자 작업 수행', auditLog);
    }
  });
  
  next();
}

// Express 앱에 적용
app.use(auditLogger);

{
  "Rules": [
    {
      "Id": "로그 아카이빙 정책",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "logs/"
      },
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "STANDARD_IA"
        },
        {
          "Days": 90,
          "StorageClass": "GLACIER"
        },
        {
          "Days": 365,
          "StorageClass": "DEEP_ARCHIVE"
        }
      ],
      "Expiration": {
        "Days": 2555  // 7년 후 삭제
      }
    }
  ]
}

# gsutil로 라이프사이클 정책 설정
cat > lifecycle.json << EOF
{
  "lifecycle": {
    "rule": [
      {
        "action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
        "condition": {"age": 30}
      },
      {
        "action": {"type": "SetStorageClass", "storageClass": "COLDLINE"},
        "condition": {"age": 90}
      },
      {
        "action": {"type": "SetStorageClass", "storageClass": "ARCHIVE"},
        "condition": {"age": 365}
      },
      {
        "action": {"type": "Delete"},
        "condition": {"age": 2555}
      }
    ]
  }
}
EOF

gsutil lifecycle set lifecycle.json gs://my-bucket

#!/usr/bin/env python3
import os
import gzip
import shutil
from datetime import datetime, timedelta
import boto3

class LogArchiver:
    def __init__(self, log_dir, archive_dir, s3_bucket=None):
        self.log_dir = log_dir
        self.archive_dir = archive_dir
        self.s3_bucket = s3_bucket
        self.s3_client = boto3.client('s3') if s3_bucket else None
    
    def compress_file(self, file_path):
        """파일을 gzip으로 압축"""
        compressed_path = f"{file_path}.gz"
        
        with open(file_path, 'rb') as f_in:
            with gzip.open(compressed_path, 'wb') as f_out:
                shutil.copyfileobj(f_in, f_out)
        
        return compressed_path
    
    def archive_old_logs(self, days=7):
        """오래된 로그 파일 아카이빙"""
        cutoff_date = datetime.now() - timedelta(days=days)
        archived_files = []
        
        for filename in os.listdir(self.log_dir):
            file_path = os.path.join(self.log_dir, filename)
            
            # 파일 수정 시간 확인
            mtime = datetime.fromtimestamp(os.path.getmtime(file_path))
            
            if mtime < cutoff_date and filename.endswith('.log'):
                print(f"아카이빙: {filename}")
                
                # 압축
                compressed = self.compress_file(file_path)
                
                # 아카이브 디렉토리로 이동
                archive_path = os.path.join(
                    self.archive_dir,
                    os.path.basename(compressed)
                )
                shutil.move(compressed, archive_path)
                
                # S3 업로드 (옵션)
                if self.s3_client:
                    self.upload_to_s3(archive_path)
                
                # 원본 삭제
                os.remove(file_path)
                archived_files.append(filename)
        
        return archived_files
    
    def upload_to_s3(self, file_path):
        """S3에 업로드"""
        key = f"archives/{os.path.basename(file_path)}"
        
        try:
            self.s3_client.upload_file(
                file_path,
                self.s3_bucket,
                key,
                ExtraArgs={'StorageClass': 'GLACIER'}
            )
            print(f"S3 업로드 완료: {key}")
        except Exception as e:
            print(f"S3 업로드 실패: {e}")
    
    def cleanup_old_archives(self, days=365):
        """오래된 아카이브 삭제"""
        cutoff_date = datetime.now() - timedelta(days=days)
        
        for filename in os.listdir(self.archive_dir):
            file_path = os.path.join(self.archive_dir, filename)
            mtime = datetime.fromtimestamp(os.path.getmtime(file_path))
            
            if mtime < cutoff_date:
                print(f"삭제: {filename}")
                os.remove(file_path)

# 사용 예시
if __name__ == '__main__':
    archiver = LogArchiver(
        log_dir='/var/log/myapp',
        archive_dir='/archives/logs',
        s3_bucket='my-log-archives'
    )
    
    # 7일 이상 된 로그 아카이빙
    archived = archiver.archive_old_logs(days=7)
    print(f"총 {len(archived)}개 파일 아카이빙 완료")
    
    # 1년 이상 된 아카이브 삭제
    archiver.cleanup_old_archives(days=365)

# crontab -e
# 매일 새벽 2시에 실행
0 2 * * * /usr/local/bin/log_archiver.py >> /var/log/archiver.log 2>&1

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'log_archiver'
    static_configs:
      - targets: ['localhost:9090']
    
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

# 알림 규칙
rule_files:
  - 'alerts.yml'

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

# alerts.yml
groups:
  - name: archiving_alerts
    rules:
      # 디스크 사용량 경고
      - alert: HighDiskUsage
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) < 0.2
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "디스크 사용량 80% 초과"
          description: "{{ $labels.instance }}의 디스크 사용량이 {{ $value }}%입니다"
      
      # 아카이빙 실패
      - alert: ArchivingFailed
        expr: rate(archiving_failures_total[5m]) > 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "아카이빙 작업 실패"
          description: "최근 5분간 {{ $value }}건의 아카이빙 실패"
      
      # 로그 급증
      - alert: LogSurge
        expr: rate(log_bytes_total[5m]) > 2 * rate(log_bytes_total[1h])
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "로그 생성량 급증"
          description: "평소보다 2배 이상의 로그가 생성되고 있습니다"