Swift: Swift CLIログ分析ツール実践チュートリアル：Swiftコア知識の総合応用

# 1. ログ内の各HTTPステータスコードの出現回数をカウント
swift log-analyzer.swift access.log --status

# 2. レスポンス時間が500msを超える遅いリクエストをフィルタ
swift log-analyzer.swift access.log --slow 500

# 3. 最も頻度の高いIPアドレスTop 10レポートを生成
swift log-analyzer.swift access.log --top-ip 10

// ============================================
// Core module: log entry model and parsing
// ============================================
import Foundation
struct LogEntry {
    let ip: String
    let date: Date
    let method: String
    let path: String
    let statusCode: Int
    let responseTime: Int
    let bytesSent: Int
}
func parseLogLine(_ line: String) -> LogEntry? {
    let parts = line.split(separator: " ").map(String.init)
    guard parts.count >= 7 else { return nil }
    let ip = parts[0]
    let method = parts[2]
    let path = parts[3]
    guard let statusCode = Int(parts[4]),
          let responseTime = Int(parts[5]),
          let bytesSent = Int(parts[6]) else { return nil }
    let date = Date()
    return LogEntry(
        ip: ip, date: date, method: method,
        path: path, statusCode: statusCode,
        responseTime: responseTime, bytesSent: bytesSent
    )
}

// ============================================
// Statistical analysis using higher-order functions
// ============================================
import Foundation
func countByStatus(_ entries: [LogEntry]) -> [Int: Int] {
    Dictionary(grouping: entries, by: { $0.statusCode })
        .mapValues { $0.count }
}
func filterSlowRequests(_ entries: [LogEntry], threshold: Int) -> [LogEntry] {
    entries.filter { $0.responseTime > threshold }
           .sorted { $0.responseTime > $1.responseTime }
}
func topIPAddresses(_ entries: [LogEntry], limit: Int) -> [(String, Int)] {
    Dictionary(grouping: entries, by: { $0.ip })
        .mapValues { $0.count }
        .sorted { $0.value > $1.value }
        .prefix(limit)
        .map { ($0.key, $0.value) }
}
print("Analysis functions defined")

// ============================================
// Aggregating error logs by hour
// ============================================
import Foundation
struct ErrorReport {
    let hour: Int
    let count: Int
    let endpoints: [String: Int]
}
func aggregateErrorsByHour(_ entries: [LogEntry]) -> [ErrorReport] {
    // Filter for error requests (status code >= 400)
    let errors = entries.filter { $0.statusCode >= 400 }
    // Group by hour
    let calendar = Calendar.current
    let grouped = Dictionary(grouping: errors) { entry in
        calendar.component(.hour, from: entry.date)
    }
    // Generate the report
    return grouped.map { hour, items in
        let endpoints = Dictionary(grouping: items, by: { $0.path })
            .mapValues { $0.count }
        return ErrorReport(hour: hour, count: items.count, endpoints: endpoints)
    }
    .sorted { $0.hour < $1.hour }
}
// Simulated data
let sampleEntries = [
    LogEntry(ip: "192.168.1.1", date: Date(), method: "GET", path: "/api/login", statusCode: 500, responseTime: 1200, bytesSent: 200),
    LogEntry(ip: "10.0.0.1", date: Date(), method: "POST", path: "/api/order", statusCode: 404, responseTime: 300, bytesSent: 50),
    LogEntry(ip: "192.168.1.2", date: Date(), method: "GET", path: "/api/login", statusCode: 500, responseTime: 800, bytesSent: 180)
]
let reports = aggregateErrorsByHour(sampleEntries)
for report in reports {
    print("Hour \(report.hour):00 -- \(report.count) errors")
    for (endpoint, count) in report.endpoints {
        print("   \(endpoint): \(count) times")
    }
}

// ============================================
// log-analyzer.swift - CLI log analysis tool
// Integrates: generics, enums, Codable, closures, file I/O
// Usage: swift log-analyzer.swift access.log --status
// ============================================
import Foundation
// MARK: - 1. Log Model
struct LogEntry {
    let ip: String
    let method: String
    let path: String
    let statusCode: Int
    let responseTime: Int
    let bytesSent: Int
    init?(from line: String) {
        let parts = line.split(separator: " ").map(String.init)
        guard parts.count >= 7,
              let code = Int(parts[4]),
              let time = Int(parts[5]),
              let bytes = Int(parts[6]) else { return nil }
        ip = parts[0]
        method = parts[2]
        path = parts[3]
        statusCode = code
        responseTime = time
        bytesSent = bytes
    }
}
// MARK: - 2. Command-Line Argument Parsing
enum Command {
    case status
    case slow(Int)
    case topIP(Int)
}
func parseCommand(from args: [String]) -> (String, Command)? {
    guard args.count >= 2 else { return nil }
    let filePath = args[1]
    guard args.count >= 3 else { return (filePath, .status) }
    switch args[2] {
    case "--status":
        return (filePath, .status)
    case "--slow":
        let threshold = args.count > 3 ? Int(args[3]) ?? 500 : 500
        return (filePath, .slow(threshold))
    case "--top-ip":
        let limit = args.count > 3 ? Int(args[3]) ?? 10 : 10
        return (filePath, .topIP(limit))
    default:
        return (filePath, .status)
    }
}
// MARK: - 3. Analysis Engine
struct Analyzer {
    let entries: [LogEntry]
    func statusBreakdown() -> [(Int, Int)] {
        Dictionary(grouping: entries, by: { $0.statusCode })
            .mapValues { $0.count }
            .sorted { $0.key < $1.key }
    }
    func slowRequests(above ms: Int) -> [LogEntry] {
        entries.filter { $0.responseTime > ms }
               .sorted { $0.responseTime > $1.responseTime }
    }
    func topIPs(limit: Int) -> [(String, Int)] {
        Dictionary(grouping: entries, by: { $0.ip })
            .mapValues { $0.count }
            .sorted { $0.value > $1.value }
            .prefix(limit)
            .map { ($0.key, $0.value) }
    }
}
// MARK: - 4. File Reading
func readLogFile(at path: String) -> Result<String, String> {
    let fm = FileManager.default
    guard fm.fileExists(atPath: path) else {
        return .failure("File not found: \(path)")
    }
    guard let content = try? String(contentsOfFile: path, encoding: .utf8) else {
        return .failure("Unable to read file: \(path)")
    }
    return .success(content)
}
// MARK: - 5. Main Program
func main() {
    let arguments = CommandLine.arguments
    guard let (filePath, command) = parseCommand(from: arguments) else {
        print("Usage: swift log-analyzer.swift <file> [options]")
        print("Options: --status, --slow <ms>, --top-ip <n>")
        return
    }
    let fileResult = readLogFile(at: filePath)
    switch fileResult {
    case .failure(let error):
        print("Error: \(error)")
        return
    case .success(let content):
        let entries = content.split(separator: "\n")
            .compactMap { LogEntry(from: String($0)) }
        let analyzer = Analyzer(entries: entries)
        print("=== Log Analysis Report ===")
        print("Total lines: \(content.split(separator: "\n").count)")
        print("Valid entries: \(entries.count)")
        switch command {
        case .status:
            print("\n--- Status Code Breakdown ---")
            for (code, count) in analyzer.statusBreakdown() {
                print("  \(code): \(count) times")
            }
        case .slow(let ms):
            let slow = analyzer.slowRequests(above: ms)
            print("\n--- Slow Requests (\(ms)ms) ---")
            for entry in slow.prefix(20) {
                print("  \(entry.ip) \(entry.method) \(entry.path) \(entry.responseTime)ms")
            }
        case .topIP(let n):
            print("\n--- Top \(n) IPs ---")
            for (ip, count) in analyzer.topIPs(limit: n) {
                print("  \(ip): \(count) times")
            }
        }
    }
}
// To run: uncomment in terminal and execute swift log-analyzer.swift access.log --status
// main()