Automating Ubuntu System Status Checks with ChatGPT

#!/usr/bin/env bash

set -euo pipefail
# set -x  # Enable for debugging if needed

########################################
# Basic Setup and Checks
########################################

DATE=$(date +"%Y-%m-%d")
WORK_DIR="/var/log/system_checking_by_chatgpt"
RAW_REPORT="$WORK_DIR/raw_report_$DATE.txt"
CHUNKS_DIR="$WORK_DIR/chunks_$DATE"
SUMMARY_DIR="$WORK_DIR/summary_$DATE"
FINAL_REPORT="$WORK_DIR/final_report_$DATE.md"  # Using Markdown format
DEBUG_LOG="$WORK_DIR/debug_$DATE.log"

mkdir -p "$WORK_DIR"
mkdir -p "$CHUNKS_DIR"
mkdir -p "$SUMMARY_DIR"

# Check required commands
REQUIRED_COMMANDS=("curl" "jq" "smartctl" "systemctl" "docker" "sensors")
for cmd in "${REQUIRED_COMMANDS[@]}"; do
    if ! command -v "$cmd" &>/dev/null; then
        echo "[ERROR] Required command $cmd is not installed." | tee -a "$DEBUG_LOG"
        exit 1
    fi
done

# Check available disk space
AVAILABLE_SPACE=$(df "$WORK_DIR" | tail -1 | awk '{print $4}')
if [ "$AVAILABLE_SPACE" -lt 102400 ]; then # less than 100MB
    echo "[ERROR] Insufficient disk space in $WORK_DIR." | tee -a "$DEBUG_LOG"
    exit 1
fi

# Logging function: output to stderr to avoid interfering with function returns
log() {
    local LEVEL=$1
    shift
    local MESSAGE="$@"
    {
        echo "[$LEVEL] $MESSAGE" | tee -a "$DEBUG_LOG" >&2
        logger -t "system_checking_by_chatgpt" "[$LEVEL] $MESSAGE"
    }
}

log "INFO" "Script execution started..."

########################################
# Load API Key
########################################

OPENAI_KEY_FILE="/home/your_user_name/.openai_api_key"
if [ ! -f "$OPENAI_KEY_FILE" ]; then
    log "ERROR" "$OPENAI_KEY_FILE does not exist."
    exit 1
fi

OPENAI_API_KEY=$(cat "$OPENAI_KEY_FILE")
if [ -z "$OPENAI_API_KEY" ]; then
    log "ERROR" "OPENAI_API_KEY is empty."
    exit 1
fi
export OPENAI_API_KEY

log "INFO" "API key successfully loaded."

API_URL="https://api.openai.com/v1/chat/completions"
MODEL="gpt-4o"

########################################
# Function Definitions
########################################

collect_system_info() {
    {
        echo "=== System Uptime ==="
        uptime
        echo ""

        echo "=== Date & Time ==="
        date
        echo ""

        echo "=== CPU & Memory Usage ==="
        top -b -n1 | head -n 20
        echo ""

        echo "=== Memory Usage (free) ==="
        free -h
        echo ""

        echo "=== Disk Usage (df) ==="
        df -h
        echo ""

        echo "=== Failed Services ==="
        systemctl list-units --state=failed
        echo ""

        echo "=== Temperature Sensors ==="
        sensors 2>/dev/null || echo "[WARNING] Could not retrieve temperature information."
        echo ""

        echo "=== NVMe / SMART Status ==="
        sudo smartctl -a /dev/nvme0n1 2>/dev/null || echo "[WARNING] Could not check /dev/nvme0n1"
        echo ""
        sudo smartctl -a /dev/nvme1n1 2>/dev/null || echo "[WARNING] Could not check /dev/nvme1n1"
        echo ""

        echo "=== Recent dmesg Entries (Last 100 lines) ==="
        dmesg | tail -n 100
        echo ""

        echo "=== System Journal (Last 300 lines, errors only) ==="
        journalctl -p err -n 300
        echo ""

        echo "=== Network Status (ss -tulpn) ==="
        ss -tulpn 2>/dev/null || echo "[WARNING] Could not retrieve network status."
        echo ""

        echo "=== Network Interface Statistics (ip -s link) ==="
        ip -s link
        echo ""

        echo "=== Docker Containers (if any) ==="
        docker ps -a 2>/dev/null || echo "[INFO] Docker is not running or not installed."
        echo ""

    } > "$RAW_REPORT"
}

generate_chunk_summaries() {
    # Split RAW_REPORT into chunks
    CHUNK_SIZE=200
    split -l $CHUNK_SIZE "$RAW_REPORT" "$CHUNKS_DIR/chunk_"

    CHUNKS=("$CHUNKS_DIR"/chunk_*)

    if [ ${#CHUNKS[@]} -eq 0 ]; then
        log "ERROR" "No chunks generated!"
        exit 1
    fi

    # Prompt for chunk summaries
    CHUNK_SYSTEM_PROMPT="You are a professional system administration consultant. The following is a portion of the system information. Please extract and summarize: (1) Important system status info (e.g., CPU/memory usage, disk usage, network status, service states, error messages), and (2) any abnormalities, errors, or issues requiring attention. Be as detailed as possible, while remaining clear and organized."

    summaries=()

    for chunk_file in "${CHUNKS[@]}"; do
        CHUNK_CONTENT=$(cat "$chunk_file")

        CHUNK_API_PAYLOAD=$(jq -n \
            --arg system_prompt "$CHUNK_SYSTEM_PROMPT" \
            --arg user_prompt "$CHUNK_CONTENT" \
            --arg model "$MODEL" \
            '{
                "model": $model,
                "messages": [
                    {"role": "system", "content": $system_prompt},
                    {"role": "user", "content": $user_prompt}
                ]
            }')

        log "INFO" "Requesting summary for $chunk_file ..."
        START_TIME=$(date +%s)
        RESPONSE=$(curl -sS -X POST "$API_URL" \
          -H "Authorization: Bearer $OPENAI_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$CHUNK_API_PAYLOAD")

        if [ $? -ne 0 ]; then
            log "ERROR" "Failed to communicate with ChatGPT API during summary phase: $chunk_file"
            exit 1
        fi
        END_TIME=$(date +%s)
        log "INFO" "API request took $((END_TIME - START_TIME)) seconds."

        SUMMARY=$(echo "$RESPONSE" | jq -r '.choices[0].message.content' 2>>"$DEBUG_LOG" || echo "")

        if [ -z "$SUMMARY" ] || [ "$SUMMARY" = "null" ]; then
            log "ERROR" "No summary returned for chunk: $chunk_file"
            echo "Raw Response: $RESPONSE" >> "$DEBUG_LOG"
            exit 1
        fi

        SUMMARY_FILE="$SUMMARY_DIR/summary_$(basename "$chunk_file").txt"
        echo "$SUMMARY" > "$SUMMARY_FILE"
        summaries+=("$SUMMARY_FILE")
    done

    # Print summary file paths to stdout only
    for s in "${summaries[@]}"; do
        echo "$s"
    done
}

combine_summaries() {
    local summaries=("$@")
    COMBINED_SUMMARY="$WORK_DIR/combined_summary_$DATE.txt"
    rm -f "$COMBINED_SUMMARY"
    touch "$COMBINED_SUMMARY"

    log "INFO" "Combining all chunk summaries..."
    {
        echo "Below are the combined summaries from multiple chunks:"
        echo "------------------------------------"
        for sfile in "${summaries[@]}"; do
            echo "=== Chunk Summary ==="
            cat "$sfile"
            echo ""
        done
    } > "$COMBINED_SUMMARY"

    echo "$COMBINED_SUMMARY"
}

generate_final_report() {
    local COMBINED_SUMMARY="$1"

    # Use a HEREDOC for the final prompt to avoid quote issues
    FINAL_SYSTEM_PROMPT=$(cat <<EOF
You are a professional system administration consultant. Below is a combined set of summaries from multiple chunks of system information. Please produce a **very detailed final report** in **Markdown format** that includes the following three main sections with clear markdown headings:

**1. Current System Status**:
Describe the current resource usage (CPU, memory, disk), service states, network status, critical logs, error messages, and any abnormal events.

**2. System Status Analysis**:
Analyze the above information, highlight potential issues, explain possible causes for anomalies, identify performance bottlenecks, unusual conditions, or risks.

**3. Recommended Solutions**:
Based on your analysis, provide feasible and specific improvement suggestions, diagnostic steps, performance optimizations, error remediation steps, and advice to enhance system stability.

Maintain clarity, logical structure, and abundant detail.
EOF
)

    FINAL_INPUT=$(cat "$COMBINED_SUMMARY")

    FINAL_API_PAYLOAD=$(jq -n \
        --arg system_prompt "$FINAL_SYSTEM_PROMPT" \
        --arg user_prompt "$FINAL_INPUT" \
        --arg model "$MODEL" \
        '{
            "model": $model,
            "messages": [
                {"role": "system", "content": $system_prompt},
                {"role": "user", "content": $user_prompt}
            ]
        }')

    log "INFO" "Starting final analysis..."
    log "DEBUG" "Final analysis payload: $FINAL_API_PAYLOAD"

    START_TIME=$(date +%s)
    RESPONSE=$(curl -sS -X POST "$API_URL" \
      -H "Authorization: Bearer $OPENAI_API_KEY" \
      -H "Content-Type: application/json" \
      -d "$FINAL_API_PAYLOAD")

    if [ $? -ne 0 ]; then
        log "ERROR" "Failed to communicate with ChatGPT API during final analysis."
        exit 1
    fi
    END_TIME=$(date +%s)
    log "INFO" "API request took $((END_TIME - START_TIME)) seconds."

    log "DEBUG" "Final analysis response: $RESPONSE"

    FINAL_ANALYSIS=$(echo "$RESPONSE" | jq -r '.choices[0].message.content' 2>>"$DEBUG_LOG" || echo "")

    if [ -z "$FINAL_ANALYSIS" ] || [ "$FINAL_ANALYSIS" = "null" ]; then
        log "ERROR" "Failed to retrieve the final analysis."
        echo "Raw Response: $RESPONSE" >> "$DEBUG_LOG"
        exit 1
    fi

    {
        echo "# Daily System Check Report - $DATE"
        echo ""
        echo "$FINAL_ANALYSIS"
    } > "$FINAL_REPORT"

    log "INFO" "Final report generated: $FINAL_REPORT"
}

########################################
# Main Flow
########################################

log "INFO" "Collecting system information..."
collect_system_info
log "INFO" "System information collected and saved in $RAW_REPORT"

mapfile -t summaries < <(generate_chunk_summaries)
COMBINED_SUMMARY_FILE=$(combine_summaries "${summaries[@]}")
generate_final_report "$COMBINED_SUMMARY_FILE"

log "INFO" "Script execution completed."