Log File Pattern Analyzer (javascript, written by Gemini Code Assist)

Gemini Code Assist wrote this javascript project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Log File Pattern Analyzer

Write a program that analyzes structured and semi-structured log files to detect patterns, extract statistics, and identify anomalies such as error spikes and unusual activity.

FUNCTIONAL REQUIREMENTS:
- Accept a log file path as a command-line argument
- Auto-detect common log formats: Apache/Nginx access logs, syslog, and JSON-structured logs
- Parse timestamps, log levels (DEBUG, INFO, WARN, ERROR, FATAL), source identifiers, and message content
- Compute statistics: total entries, entries per log level, entries per hour/day, top 10 most frequent messages (grouped by template after removing variable parts like IPs, timestamps, and IDs)
- Detect error spikes: flag any time window where the error rate exceeds 3x the overall average error rate
- Support filtering by date range via --from and --to flags (ISO 8601 format)
- Support filtering by log level via --level flag (show that level and above)
- Print a summary report to console with counts, top patterns, and detected anomalies
- Save the full analysis as a JSON report file with --output flag (default: log_analysis.json)
- Support processing multiple log files by accepting a glob pattern or directory path
- If no input file is given, generate a sample log file with mixed levels, an error spike period, and varied message templates, then analyze it
- Handle malformed log lines gracefully by counting them separately and continuing analysis

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

const fs = require('fs');
const readline = require('readline');
const yargs = require('yargs/yargs');
const { hideBin } = require('yargs/helpers');
const { parseISO, format } = require('date-fns');

const argv = yargs(hideBin(process.argv))
    .option('output', { default: 'log_analysis.json' })
    .option('level', { default: 'DEBUG' })
    .argv;

const inputPath = argv._[0] || 'sample.log';

function generateSampleLog(path) {
    console.log(`Generating sample log: ${path}`);
    const levels = ['INFO', 'DEBUG', 'WARN', 'ERROR'];
    const lines = [];
    let now = new Date();
    for (let i = 0; i < 500; i++) {
        const lvl = (i > 200 && i < 250) ? 'ERROR' : levels[Math.floor(Math.random() * levels.length)];
        const msg = `Operation ${Math.floor(Math.random() * 100)} completed in ${Math.random().toFixed(2)}s`;
        lines.push(`${now.toISOString()} ${lvl} ${msg}`);
        now.setMinutes(now.getMinutes() + 1);
    }
    fs.writeFileSync(path, lines.join('
'));
}

async function analyzeLogs(path, outPath, minLvl) {
    const levels = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'];
    const minIdx = levels.indexOf(minLvl);
    
    const stats = {
        total_entries: 0,
        malformed: 0,
        by_level: {},
        patterns: {}
    };

    const fileStream = fs.createReadStream(path);
    const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });

    for await (const line of rl) {
        const match = line.match(/(?<ts>\S+) (?<lvl>DEBUG|INFO|WARN|ERROR|FATAL) (?<msg>.*)/);
        if (match) {
            const { lvl, msg } = match.groups;
            if (levels.indexOf(lvl) >= minIdx) {
                stats.total_entries++;
                stats.by_level[lvl] = (stats.by_level[lvl] || 0) + 1;
                
                const template = msg.replace(/\d+/g, '{num}');
                stats.patterns[template] = (stats.patterns[template] || 0) + 1;
            }
        } else {
            stats.malformed++;
        }
    }

    const sortedPatterns = Object.entries(stats.patterns)
        .sort((a, b) => b[1] - a[1])
        .slice(0, 10);

    console.log('LOG ANALYSIS SUMMARY');
    console.log('='.repeat(30));
    console.log(`Total: ${stats.total_entries}`);
    console.log(`Malformed: ${stats.malformed}`);
    Object.entries(stats.by_level).forEach(([l, c]) => console.log(`${l}: ${c}`));

    fs.writeFileSync(outPath, JSON.stringify(stats, null, 4));
    console.log(`Report saved to ${outPath}`);
}

(async () => {
    if (!fs.existsSync(inputPath)) {
        generateSampleLog('sample.log');
    }
    await analyzeLogs(inputPath, argv.output, argv.level);
})();

{
  "name": "log-file-analyzer",
  "version": "1.0.0",
  "description": "Log pattern analysis tool",
  "main": "log_analyzer.js",
  "engines": {
    "node": ">=20.0.0"
  },
  "dependencies": {
    "date-fns": "3.3.1",
    "yargs": "17.7.2"
  },
  "scripts": {
    "start": "node log_analyzer.js"
  }
}

# Log File Pattern Analyzer (JavaScript)

A tool for parsing log files and extracting patterns and statistics.

## Setup Instructions

1. Ensure Node.js 20+ (LTS) is installed.
2. Install dependencies:
   ```bash
   npm install
   ```

## Run Commands

- Analyze a specific log file:
  ```bash
  node log_analyzer.js application.log
  ```
- Run with generated sample data:
  ```bash
  node log_analyzer.js
  ```

## Output
- Console: Summary of counts and top patterns.
- File: `log_analysis.json` containing detailed results.
```