MACRO NEPAL
Complete Guide to Bash uptime Command
awiskar acharya
March 11, 2026
8:02 am

Introduction to uptime

The uptime command is a fundamental Unix/Linux utility that displays how long the system has been running, along with current time, number of users, and system load averages. It's an essential tool for system administrators to quickly assess system stability and performance.

Key Concepts

  • System Runtime: How long the system has been operational since last boot
  • Current Time: System clock time at the moment of command execution
  • User Sessions: Number of users currently logged in
  • Load Averages: System load over 1, 5, and 15 minutes
  • System Health: Quick indicator of system stability and performance

1. Basic Usage

Simple Uptime Display

#!/bin/bash
# Basic uptime command
uptime
# Example output:
# 14:23:42 up 5 days, 2:15, 3 users, load average: 0.08, 0.03, 0.01
# Pretty format
echo "System uptime information:"
echo "=========================="
uptime
# Show only uptime (using -p for pretty format on Linux)
uptime -p
# Show since when system has been up (Linux)
uptime -s
# Show version
uptime -V

Understanding Output

#!/bin/bash
# Parse uptime output components
uptime_info=$(uptime)
# Extract current time
current_time=$(echo "$uptime_info" | awk '{print $1}')
echo "Current time: $current_time"
# Extract uptime string
uptime_str=$(echo "$uptime_info" | awk -F'up ' '{print $2}' | awk -F',' '{print $1}')
echo "System uptime: $uptime_str"
# Extract number of users
users=$(echo "$uptime_info" | awk -F'users?' '{print $2}' | awk '{print $1}')
echo "Users logged in: $users"
# Extract load averages
loads=$(echo "$uptime_info" | awk -F'load average:' '{print $2}')
echo "Load averages:$loads"
# Parse load averages separately
load_1=$(echo "$loads" | awk -F',' '{print $1}' | tr -d ' ')
load_5=$(echo "$loads" | awk -F',' '{print $2}' | tr -d ' ')
load_15=$(echo "$loads" | awk -F',' '{print $3}' | tr -d ' ')
echo "1 minute load: $load_1"
echo "5 minute load: $load_5"
echo "15 minute load: $load_15"

2. Uptime Information Components

Detailed Breakdown

#!/bin/bash
# Comprehensive uptime report
report_uptime() {
local uptime_output=$(uptime)
echo "=== System Uptime Report ==="
echo "Generated: $(date)"
echo
# Current time
echo "Current time: $(date)"
# System uptime
local uptime_str=$(echo "$uptime_output" | sed 's/.*up //' | sed 's/,.*//')
echo "System uptime: $uptime_str"
# Calculate uptime in seconds
local uptime_seconds=$(awk '{print int($1)}' /proc/uptime 2>/dev/null)
if [ -n "$uptime_seconds" ]; then
local days=$((uptime_seconds / 86400))
local hours=$(( (uptime_seconds % 86400) / 3600 ))
local minutes=$(( (uptime_seconds % 3600) / 60 ))
local seconds=$((uptime_seconds % 60))
echo "Uptime (seconds): $uptime_seconds"
echo "Uptime (detailed): ${days}d ${hours}h ${minutes}m ${seconds}s"
fi
# Users
local users=$(echo "$uptime_output" | awk -F'users?' '{print $2}' | awk '{print $1}')
echo "Users logged in: $users"
# Load averages
local loads=$(echo "$uptime_output" | awk -F'load average:' '{print $2}')
local load_1=$(echo "$loads" | awk -F',' '{print $1}' | tr -d ' ')
local load_5=$(echo "$loads" | awk -F',' '{print $2}' | tr -d ' ')
local load_15=$(echo "$loads" | awk -F',' '{print $3}' | tr -d ' ')
echo "Load averages:"
echo "  1 minute:  $load_1"
echo "  5 minutes: $load_5"
echo "  15 minutes:$load_15"
# CPU core count for context
local cores=$(nproc 2>/dev/null || echo "unknown")
echo "CPU cores: $cores"
if [ "$cores" != "unknown" ]; then
echo "Load per core (1 min): $(echo "scale=2; $load_1 / $cores" | bc)"
fi
}
# Usage
report_uptime

Different Uptime Formats

#!/bin/bash
# Linux specific formats
if [ "$(uname)" = "Linux" ]; then
# Pretty format
uptime -p
# Since timestamp
uptime -s
# Normal format
uptime
fi
# BSD/macOS format (different output)
if [ "$(uname)" = "Darwin" ]; then
uptime
# Output: 14:23  up 5 days, 2:15, 3 users, load averages: 0.08 0.03 0.01
fi
# Custom formatting function
format_uptime() {
local uptime_seconds=$(awk '{print int($1)}' /proc/uptime 2>/dev/null)
if [ -n "$uptime_seconds" ]; then
local days=$((uptime_seconds / 86400))
local remainder=$((uptime_seconds % 86400))
local hours=$((remainder / 3600))
local minutes=$(((remainder % 3600) / 60))
if [ $days -gt 0 ]; then
echo "${days}d ${hours}h ${minutes}m"
elif [ $hours -gt 0 ]; then
echo "${hours}h ${minutes}m"
else
echo "${minutes}m"
fi
else
# Fallback to parsing uptime command
uptime | sed 's/.*up //' | sed 's/,.*//'
fi
}
echo "System uptime: $(format_uptime)"

3. Load Averages

Understanding Load Averages

#!/bin/bash
# Load average explanation
explain_load() {
local load_1="$1"
local cores=$(nproc)
echo "Load average explanation:"
echo "CPU cores: $cores"
echo "1-minute load: $load_1"
# Interpret load
if (( $(echo "$load_1 < $cores" | bc -l) )); then
echo "✓ System is underutilized (load < cores)"
elif (( $(echo "$load_1 == $cores" | bc -l) )); then
echo "✓ System is fully utilized (load = cores)"
elif (( $(echo "$load_1 < $cores * 1.5" | bc -l) )); then
echo "⚠ System is moderately loaded (load < 1.5× cores)"
else
echo "✗ System is heavily loaded (load > 1.5× cores)"
fi
# Trend analysis
if (( $(echo "$load_1 > $load_5" | bc -l) )); then
echo "↑ Load increasing (1m > 5m)"
elif (( $(echo "$load_1 < $load_5" | bc -l) )); then
echo "↓ Load decreasing (1m < 5m)"
else
echo "→ Load stable"
fi
}
# Get current load averages
get_loads() {
uptime | awk -F'load average:' '{print $2}' | \
awk -F',' '{gsub(/ /,""); print $1, $2, $3}'
}
# Monitor load averages
monitor_load() {
local threshold="${1:-2.0}"
local interval="${2:-5}"
echo "Monitoring load averages (threshold: $threshold)"
echo "Press Ctrl+C to stop"
echo
while true; do
loads=$(get_loads)
read load_1 load_5 load_15 <<< "$loads"
timestamp=$(date '+%H:%M:%S')
if (( $(echo "$load_1 > $threshold" | bc -l) )); then
echo "$timestamp - HIGH LOAD: $load_1 (threshold: $threshold)"
else
echo "$timestamp - Load: $load_1, $load_5, $load_15"
fi
sleep "$interval"
done
}
# Load average history
load_history() {
local samples="${1:-60}"
local interval="${2:-1}"
echo "Collecting $samples load samples (${interval}s interval)..."
for i in $(seq 1 "$samples"); do
load=$(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $1}' | tr -d ' ')
echo "$(date +%s) $load"
sleep "$interval"
done
}
# Usage
loads=$(get_loads)
explain_load $loads
# monitor_load 4.0 2
# load_history 30 2 > load_data.txt

4. Uptime Monitoring Scripts

System Uptime Monitor

#!/bin/bash
# Comprehensive uptime monitoring script
UPTIME_LOG="/var/log/uptime_history.log"
ALERT_EMAIL="[email protected]"
REBOOT_THRESHOLD=300  # 5 minutes threshold for detecting crashes
log_uptime() {
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
local uptime_seconds=$(awk '{print int($1)}' /proc/uptime 2>/dev/null)
local load=$(uptime | awk -F'load average:' '{print $2}' | xargs)
local users=$(who | wc -l)
echo "$timestamp|$uptime_seconds|$load|$users" >> "$UPTIME_LOG"
}
check_reboot() {
local last_uptime=$(tail -1 "$UPTIME_LOG" 2>/dev/null | cut -d'|' -f2)
local current_uptime=$(awk '{print int($1)}' /proc/uptime)
if [ -n "$last_uptime" ] && [ -n "$current_uptime" ]; then
# If uptime decreased significantly, system rebooted
if [ "$current_uptime" -lt "$((last_uptime - REBOOT_THRESHOLD))" ]; then
local reboot_time=$(date)
echo "System reboot detected at $reboot_time"
# Send alert
echo "System rebooted at $reboot_time" | \
mail -s "Reboot Alert: $(hostname)" "$ALERT_EMAIL"
# Log reboot
echo "$(date): System rebooted" >> "${UPTIME_LOG%.log}.reboot.log"
fi
fi
}
generate_report() {
local days="${1:-7}"
echo "Uptime Report for $(hostname)"
echo "Generated: $(date)"
echo "================================"
echo
echo "Current Status:"
echo "  Uptime: $(uptime -p)"
echo "  Since: $(uptime -s)"
echo "  Users: $(who | wc -l)"
echo "  Load: $(uptime | awk -F'load average:' '{print $2}')"
echo
if [ -f "$UPTIME_LOG" ]; then
echo "Last $days days statistics:"
# Calculate average load
tail -n $((days * 24 * 6)) "$UPTIME_LOG" | awk -F'|' '
BEGIN {
sum1=0; sum5=0; sum15=0; count=0
}
{
split($3, load, ", ")
gsub(/ /, "", load[1])
gsub(/ /, "", load[2])
gsub(/ /, "", load[3])
sum1 += load[1]
sum5 += load[2]
sum15 += load[3]
count++
}
END {
if (count > 0) {
printf "  Average 1-min load:  %.2f\n", sum1/count
printf "  Average 5-min load:  %.2f\n", sum5/count
printf "  Average 15-min load: %.2f\n", sum15/count
}
}'
# Count reboots
reboot_count=$(grep -c "System rebooted" "${UPTIME_LOG%.log}.reboot.log" 2>/dev/null)
echo "  Reboots: $reboot_count"
fi
}
# Continuous monitoring
monitor_uptime() {
local interval="${1:-60}"  # Check every minute by default
echo "Starting uptime monitoring (interval: ${interval}s)"
echo "Log file: $UPTIME_LOG"
echo "Press Ctrl+C to stop"
while true; do
log_uptime
check_reboot
sleep "$interval"
done
}
# Main
case "${1:-}" in
log)
log_uptime
;;
monitor)
monitor_uptime "${2:-60}"
;;
report)
generate_report "${2:-7}"
;;
*)
echo "Usage: $0 {log|monitor|report}"
exit 1
;;
esac

Uptime Dashboard

#!/bin/bash
# Real-time uptime dashboard
DASHBOARD_REFRESH=2
draw_dashboard() {
clear
echo "╔════════════════════════════════════════════════════════════╗"
echo "║                 SYSTEM UPTIME DASHBOARD                    ║"
echo "╠════════════════════════════════════════════════════════════╣"
# Hostname and time
echo "║ Host: $(hostname)"
echo "║ Date: $(date)"
echo "╠════════════════════════════════════════════════════════════╣"
# Uptime information
local uptime_output=$(uptime)
local current_time=$(date '+%H:%M:%S')
local uptime_str=$(uptime -p 2>/dev/null || uptime | sed 's/.*up //' | sed 's/,.*//')
local users=$(who | wc -l)
local loads=$(uptime | awk -F'load average:' '{print $2}' | xargs)
echo "║ Current time: $current_time"
echo "║ System uptime: $uptime_str"
echo "║ Users logged: $users"
echo "║ Load averages: $loads"
echo "╠════════════════════════════════════════════════════════════╣"
# Load average graph
echo "║ Load Average Graph (1-minute):"
local load_1=$(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $1}' | tr -d ' ')
local cores=$(nproc)
local bar_length=40
# Calculate bar length based on load
if (( $(echo "$load_1 > 0" | bc -l) )); then
local filled=$(echo "scale=0; ($load_1 / $cores) * $bar_length" | bc 2>/dev/null || echo 0)
if [ "$filled" -gt "$bar_length" ]; then
filled=$bar_length
fi
printf "║ Load: %5s/%-5s [" "$load_1" "$cores"
for i in $(seq 1 $bar_length); do
if [ $i -le "$filled" ]; then
printf "#"
else
printf "."
fi
done
printf "]\n"
fi
echo "╠════════════════════════════════════════════════════════════╣"
# Recent logins
echo "║ Recent logins (last 5):"
last -5 | head -5 | while read line; do
printf "║ %-50.50s\n" "$line"
done
echo "╚════════════════════════════════════════════════════════════╝"
}
# Main loop
while true; do
draw_dashboard
sleep "$DASHBOARD_REFRESH"
done

5. Uptime in Scripts

Conditional Scripts Based on Uptime

#!/bin/bash
# Check if system just booted (less than 10 minutes)
if [ $(awk '{print int($1)}' /proc/uptime) -lt 600 ]; then
echo "System recently booted, running startup checks..."
# Run startup scripts
./check_system.sh
./start_services.sh
else
echo "System running normally"
fi
# Schedule maintenance based on uptime
schedule_maintenance() {
local uptime_days=$(awk '{print int($1/86400)}' /proc/uptime)
if [ $uptime_days -gt 30 ]; then
echo "System has been up for $uptime_days days - schedule maintenance soon"
# Send notification
echo "System $(hostname) has been up for $uptime_days days" | \
mail -s "Maintenance reminder" [email protected]
fi
}
# Graceful restart planning
plan_restart() {
local uptime_days=$(awk '{print int($1/86400)}' /proc/uptime)
local users=$(who | wc -l)
local load=$(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $1}' | tr -d ' ')
if [ $uptime_days -gt 60 ]; then
if [ $users -eq 0 ] && [ $(echo "$load < 0.5" | bc) -eq 1 ]; then
echo "Good time to restart system"
# shutdown -r +5 "Scheduled restart"
else
echo "System busy, postpone restart"
fi
fi
}

Monitoring and Alerting

#!/bin/bash
# Uptime-based alerts
UPTIME_ALERT_DAYS=90
LOAD_ALERT_THRESHOLD=5.0
check_uptime_alert() {
local uptime_days=$(awk '{print int($1/86400)}' /proc/uptime)
if [ $uptime_days -gt $UPTIME_ALERT_DAYS ]; then
echo "WARNING: System has been up for $uptime_days days"
echo "Consider scheduling a maintenance reboot"
return 1
fi
return 0
}
check_load_alert() {
local load_1=$(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $1}' | tr -d ' ')
if (( $(echo "$load_1 > $LOAD_ALERT_THRESHOLD" | bc -l) )); then
echo "CRITICAL: Load average is $load_1"
echo "Investigate system performance"
return 1
fi
return 0
}
# Combined health check
health_check() {
local status=0
echo "=== System Health Check ==="
echo "Time: $(date)"
echo "Host: $(hostname)"
echo
check_uptime_alert || status=1
check_load_alert || status=1
echo
if [ $status -eq 0 ]; then
echo "✓ All checks passed"
else
echo "✗ Some checks failed"
fi
return $status
}
# Run health check and alert if needed
if ! health_check > /tmp/health_check.$$; then
cat /tmp/health_check.$$ | mail -s "System Health Alert" [email protected]
fi
rm -f /tmp/health_check.$$

6. Integration with Other Commands

Combining with Other Tools

#!/bin/bash
# Create system status report
cat << EOF
System Status Report
====================
Date: $(date)
Host: $(hostname)
--- Uptime Information ---
$(uptime)
--- Memory Information ---
$(free -h)
--- Disk Usage ---
$(df -h /)
--- Network Connections ---
$(ss -tun | head -5)
--- Recent Logins ---
$(last | head -3)
EOF
# Watch uptime with other metrics
watch -n 5 'uptime; echo; free -h; echo; df -h /'
# Create CSV log
log_metrics() {
local timestamp=$(date +%s)
local uptime=$(awk '{print $1}' /proc/uptime)
local load=$(uptime | awk -F'load average:' '{print $2}' | xargs | tr ' ' ',')
local mem=$(free | awk '/Mem:/ {print $3}')
local cpu=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}')
echo "$timestamp,$uptime,$load,$mem,$cpu" >> metrics.csv
}
# Plot load averages with gnuplot
plot_load() {
local data_file="/tmp/load_data.txt"
# Collect data
for i in {1..60}; do
uptime | awk -F'load average:' '{print $2}' >> "$data_file"
sleep 1
done
# Create gnuplot script
cat > /tmp/plot.gnuplot << EOF
set terminal png
set output "load_graph.png"
set title "Load Averages Over Time"
set xlabel "Time (seconds)"
set ylabel "Load"
plot "$data_file" using 1 with lines title "1 min", \
"$data_file" using 2 with lines title "5 min", \
"$data_file" using 3 with lines title "15 min"
EOF
gnuplot /tmp/plot.gnuplot
echo "Graph saved to load_graph.png"
}

API Endpoint for Monitoring

#!/bin/bash
# Simple HTTP server for uptime monitoring
while true; do
nc -l -p 8080 -q 1 << EOF
HTTP/1.1 200 OK
Content-Type: application/json
{
"hostname": "$(hostname)",
"timestamp": "$(date -Iseconds)",
"uptime": {
"seconds": $(awk '{print int($1)}' /proc/uptime),
"pretty": "$(uptime -p | sed 's/up //')"
},
"users": $(who | wc -l),
"load": {
"1min": $(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $1}' | tr -d ' '),
"5min": $(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $2}' | tr -d ' '),
"15min": $(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{print $3}' | tr -d ' ')
}
}
EOF
done

7. Historical Analysis

Uptime History Tracking

#!/bin/bash
# Track uptime history in SQLite
DB_FILE="/var/lib/uptime/uptime.db"
init_db() {
mkdir -p "$(dirname "$DB_FILE")"
sqlite3 "$DB_FILE" << EOF
CREATE TABLE IF NOT EXISTS uptime (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
uptime_seconds INTEGER,
load_1 REAL,
load_5 REAL,
load_15 REAL,
users INTEGER
);
CREATE INDEX IF NOT EXISTS idx_timestamp ON uptime(timestamp);
EOF
}
record_uptime() {
local uptime_seconds=$(awk '{print int($1)}' /proc/uptime)
local loads=$(uptime | awk -F'load average:' '{print $2}' | awk -F',' '{gsub(/ /,""); print $1, $2, $3}')
read load_1 load_5 load_15 <<< "$loads"
local users=$(who | wc -l)
sqlite3 "$DB_FILE" << EOF
INSERT INTO uptime (uptime_seconds, load_1, load_5, load_15, users)
VALUES ($uptime_seconds, $load_1, $load_5, $load_5, $users);
EOF
}
analyze_history() {
local days="${1:-30}"
sqlite3 "$DB_FILE" << EOF
.headers on
.mode column
SELECT 
date(timestamp) as date,
avg(uptime_seconds) as avg_uptime,
avg(load_1) as avg_load_1,
max(load_1) as max_load_1,
avg(users) as avg_users
FROM uptime
WHERE timestamp >= datetime('now', '-$days days')
GROUP BY date(timestamp)
ORDER BY date DESC;
EOF
}
find_reboots() {
sqlite3 "$DB_FILE" << EOF
SELECT 
a.timestamp as boot_time,
b.timestamp as next_record,
(julianday(b.timestamp) - julianday(a.timestamp)) * 24 * 60 as minutes_running
FROM uptime a
JOIN uptime b ON a.id + 1 = b.id
WHERE b.uptime_seconds < a.uptime_seconds - 300;
EOF
}
# Setup cron job
# */5 * * * * /usr/local/bin/uptime_recorder.sh

8. Uptime for Different Unix Variants

Cross-Platform Compatibility

#!/bin/bash
# Detect OS and use appropriate commands
detect_os() {
case "$(uname -s)" in
Linux)
echo "linux"
;;
Darwin)
echo "macos"
;;
FreeBSD)
echo "freebsd"
;;
CYGWIN*|MINGW*|MSYS*)
echo "windows"
;;
*)
echo "unknown"
;;
esac
}
# Cross-platform uptime function
get_uptime_seconds() {
local os=$(detect_os)
case "$os" in
linux)
awk '{print int($1)}' /proc/uptime
;;
macos|freebsd)
boot_time=$(sysctl -n kern.boottime | awk -F'[= ,]' '{print $4}')
current_time=$(date +%s)
echo $((current_time - boot_time))
;;
windows)
# Using cygwin/msys
uptime | awk -F'[up ]' '{print $3}' | awk -F',' '{print $1}' | \
awk '{if (NF==2) print $1*60+$2; else print $1*3600+$2*60+$3}'
;;
*)
echo "0"
;;
esac
}
# Cross-platform pretty uptime
get_pretty_uptime() {
local seconds=$(get_uptime_seconds)
local days=$((seconds / 86400))
local hours=$(( (seconds % 86400) / 3600 ))
local minutes=$(( (seconds % 3600) / 60 ))
if [ $days -gt 0 ]; then
echo "${days}d ${hours}h ${minutes}m"
elif [ $hours -gt 0 ]; then
echo "${hours}h ${minutes}m"
else
echo "${minutes}m"
fi
}
# Usage
echo "OS: $(detect_os)"
echo "Uptime seconds: $(get_uptime_seconds)"
echo "Pretty uptime: $(get_pretty_uptime)"

9. Performance Impact

Lightweight Monitoring

#!/bin/bash
# Measure uptime command performance
measure_performance() {
local iterations="${1:-1000}"
echo "Measuring uptime performance ($iterations iterations)"
# Time uptime command
time for i in $(seq 1 "$iterations"); do
uptime > /dev/null
done
# Time reading /proc/uptime directly
time for i in $(seq 1 "$iterations"); do
cat /proc/uptime > /dev/null 2>&1
done
}
# Efficient load checking for scripts
get_load() {
# Read directly from /proc/loadavg on Linux (more efficient)
if [ -f /proc/loadavg ]; then
awk '{print $1, $2, $3}' /proc/loadavg
else
uptime | awk -F'load average:' '{print $2}' | xargs
fi
}
# Usage in performance-critical scripts
check_load_fast() {
local load_1=$(awk '{print $1}' /proc/loadavg 2>/dev/null)
if [ -n "$load_1" ] && (( $(echo "$load_1 > 10" | bc -l) )); then
echo "High load detected: $load_1"
fi
}

10. Best Practices and Tips

Shell Configuration

# ~/.bashrc additions
# Aliases
alias up='uptime'
alias upp='uptime -p'
alias ups='uptime -s'
alias upw='watch -n 1 uptime'
alias upl='uptime | awk -F"load average:" "{print \$2}"'
# Function to show uptime with colors
upcolor() {
local output=$(uptime)
local load=$(echo "$output" | awk -F'load average:' '{print $2}')
# Color code based on load
if [ -n "$load" ]; then
local load_1=$(echo "$load" | awk -F',' '{print $1}' | tr -d ' ')
local cores=$(nproc)
if (( $(echo "$load_1 < $cores" | bc -l) )); then
echo -e "\033[32m$output\033[0m"  # Green
elif (( $(echo "$load_1 < $cores * 2" | bc -l) )); then
echo -e "\033[33m$output\033[0m"  # Yellow
else
echo -e "\033[31m$output\033[0m"  # Red
fi
else
echo "$output"
fi
}
# Function to show uptime with additional info
upinfo() {
echo "=== System Uptime Information ==="
uptime
echo
echo "Boot time: $(who -b 2>/dev/null || sysctl -n kern.boottime 2>/dev/null)"
echo "Processes: $(ps aux | wc -l)"
echo "Open files: $(lsof | wc -l 2>/dev/null)"
}
# Add to prompt (show uptime in prompt)
update_prompt() {
local up=$(awk '{print int($1/3600)}' /proc/uptime 2>/dev/null)
if [ -n "$up" ]; then
export PS1="\u@\h [up:${up}h] \w\$ "
fi
}
PROMPT_COMMAND=update_prompt

System Administration Tips

#!/bin/bash
# 1. Monitor for long uptimes
check_long_uptime() {
local days=$(awk '{print int($1/86400)}' /proc/uptime)
if [ $days -gt 365 ]; then
echo "⚠️  System has been up for over a year!"
fi
}
# 2. Track uptime records
record_uptime() {
local record_file="/var/log/uptime_record"
local current=$(awk '{print int($1)}' /proc/uptime)
local record=$(cat "$record_file" 2>/dev/null || echo 0)
if [ $current -gt $record ]; then
echo $current > "$record_file"
echo "New uptime record: $(get_pretty_uptime)"
fi
}
# 3. Pre-reboot checks
pre_reboot_check() {
local uptime=$(awk '{print int($1/86400)}' /proc/uptime)
local users=$(who | wc -l)
local load=$(awk '{print $1}' /proc/loadavg)
echo "Pre-reboot checklist:"
echo "✓ Uptime: $uptime days"
echo "✓ Users: $users"
echo "✓ Load: $load"
if [ $users -gt 0 ]; then
echo "✗ Users logged in - notify them first"
return 1
fi
if (( $(echo "$load > 0.5" | bc -l) )); then
echo "✗ System load high - wait for it to calm down"
return 1
fi
echo "✓ System ready for reboot"
return 0
}
# 4. Uptime-based service restarts
restart_services_based_on_uptime() {
local days=$(awk '{print int($1/86400)}' /proc/uptime)
if [ $days -gt 7 ]; then
echo "System up for $days days - restarting services..."
systemctl restart nginx
systemctl restart postgresql
fi
}

Conclusion

The uptime command is a simple yet powerful tool for system monitoring:

Key Takeaways

  1. Basic Information: Shows current time, uptime, users, and load averages
  2. System Stability: Long uptimes indicate system stability
  3. Load Averages: Quick view of system load over 1, 5, and 15 minutes
  4. User Sessions: Number of currently logged-in users
  5. Performance Indicator: Load averages help identify performance issues
  6. Historical Data: Can be logged for trend analysis
  7. Alerting: Can trigger alerts based on thresholds
  8. Cross-platform: Available on all Unix-like systems
  9. Lightweight: Minimal performance impact
  10. Script-friendly: Easy to parse and integrate

Best Practices Summary

  1. Monitor regularly: Set up cron jobs to log uptime
  2. Track trends: Analyze historical data for patterns
  3. Set alerts: Notify on high load or unexpected reboots
  4. Consider context: Interpret load averages relative to CPU cores
  5. Combine with other metrics: Use alongside CPU, memory, disk stats
  6. Pre-reboot checks: Verify system state before maintenance
  7. Document records: Keep track of uptime milestones
  8. Cross-platform awareness: Handle OS differences in scripts
  9. Performance conscious: Use /proc/loadavg for efficient access
  10. Visual monitoring: Create dashboards for real-time views

The uptime command provides essential information at a glance and, when combined with other tools and proper monitoring, helps maintain system health and reliability.

Category : BASH

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper