Email Alerts Configuration with mailx

Introduction

Proactive monitoring requires effective notification systems that alert administrators when critical events occur. Email alerts remain one of the most reliable and universally accessible notification methods, allowing system administrators to receive immediate notifications about server issues, security incidents, and performance anomalies regardless of their location.

The mailx utility (also known as mail, bsd-mailx, or s-nail depending on your distribution) is a lightweight command-line email client that enables scripts and applications to send emails directly from Linux servers. When integrated with monitoring scripts, cron jobs, and system services, mailx transforms passive logging into an active alerting system that notifies you the moment something requires attention.

This comprehensive guide covers everything from basic mailx installation and configuration to advanced alerting strategies including email templates, attachment handling, HTML emails, integration with external SMTP servers, and best practices for preventing alert fatigue. Whether you're setting up simple cron job notifications or building a sophisticated monitoring alerting system, mastering mailx is essential for effective system administration.

Prerequisites

Before configuring email alerts with mailx, ensure you have:

• A Linux server (Ubuntu 20.04/22.04, Debian 10/11, CentOS 7/8, Rocky Linux 8/9, or similar)
• Root or sudo access to install packages and configure services
• Basic understanding of email protocols (SMTP, MTA)
• Access to an SMTP server (local or external like Gmail, SendGrid, etc.)
• Valid email addresses for sending and receiving alerts

Recommended Knowledge:

• Basic Bash scripting for creating monitoring scripts
• Understanding of mail transfer agents (MTAs)
• Familiarity with cron for scheduling
• Basic networking concepts

Installing mailx

The mailx package name varies across distributions. Let's install the appropriate version for your system.

On Ubuntu/Debian

# Update package repository
sudo apt update

# Install mailutils (includes mailx)
sudo apt install mailutils -y

# Verify installation
mail -V
which mail

Alternative for bsd-mailx:

# Install bsd-mailx if preferred
sudo apt install bsd-mailx -y

On CentOS/Rocky Linux/AlmaLinux

# Install mailx
sudo yum install mailx -y

# On CentOS 8/Rocky Linux 8+, use s-nail
sudo dnf install s-nail -y

# Verify installation
mail -V

Verify Installation

# Check mail command location
which mail

# View mail version
mail -V

# Test basic functionality
echo "Test email" | mail -s "Test Subject" [email protected]

Configuring Local Mail Transfer Agent (MTA)

For mailx to send emails, you need a Mail Transfer Agent. The most common options are Postfix and sendmail.

Installing and Configuring Postfix

Installation:

# Ubuntu/Debian
sudo apt install postfix -y

# CentOS/Rocky Linux
sudo yum install postfix -y

Basic Configuration:

# Edit Postfix main configuration
sudo nano /etc/postfix/main.cf

For local delivery only:

# /etc/postfix/main.cf
myhostname = server.example.com
mydomain = example.com
myorigin = $mydomain
inet_interfaces = loopback-only
mydestination = $myhostname, localhost.$mydomain, localhost
relayhost =

For relay via external SMTP:

# /etc/postfix/main.cf
relayhost = [smtp.gmail.com]:587
smtp_use_tls = yes
smtp_sasl_auth_enable = yes
smtp_sasl_security_options = noanonymous
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt

Create SASL password file:

# Create password file
sudo nano /etc/postfix/sasl_passwd

[smtp.gmail.com]:587 [email protected]:app-password

# Set permissions and create hash database
sudo chmod 600 /etc/postfix/sasl_passwd
sudo postmap /etc/postfix/sasl_passwd

# Restart Postfix
sudo systemctl restart postfix
sudo systemctl enable postfix

Configuring for Gmail SMTP

Generate Gmail App Password:

1. Enable 2-factor authentication on your Gmail account
2. Go to Google Account > Security > App passwords
3. Generate an app password for "Mail"

Configure Postfix for Gmail:

# /etc/postfix/main.cf
relayhost = [smtp.gmail.com]:587
smtp_use_tls = yes
smtp_sasl_auth_enable = yes
smtp_sasl_security_options = noanonymous
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt
smtp_tls_session_cache_database = btree:/var/lib/postfix/smtp_tls_session_cache

SASL password:

# /etc/postfix/sasl_passwd
[smtp.gmail.com]:587 [email protected]:your-app-password

# Process and restart
sudo postmap /etc/postfix/sasl_passwd
sudo chmod 600 /etc/postfix/sasl_passwd
sudo systemctl restart postfix

Configuring for SendGrid SMTP

# /etc/postfix/main.cf
relayhost = [smtp.sendgrid.net]:587
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous
smtp_tls_security_level = encrypt
header_size_limit = 4096000

SASL password for SendGrid:

# /etc/postfix/sasl_passwd
[smtp.sendgrid.net]:587 apikey:YOUR_SENDGRID_API_KEY

sudo postmap /etc/postfix/sasl_passwd
sudo chmod 600 /etc/postfix/sasl_passwd
sudo systemctl restart postfix

Basic mailx Usage

Sending Simple Emails

Basic email command:

# Simple email with subject
echo "This is the email body" | mail -s "Subject Line" [email protected]

# Email with multiple recipients
echo "Email body" | mail -s "Subject" [email protected] [email protected]

# Email from file
mail -s "Subject" [email protected] < email-body.txt

# Interactive email composition
mail -s "Subject" [email protected]
# Type message, then Ctrl+D to send

Setting From Address

# Using -r flag (works on most systems)
echo "Email body" | mail -s "Subject" -r "[email protected]" [email protected]

# Using -a flag for additional headers
echo "Email body" | mail -s "Subject" -a "From: [email protected]" [email protected]

# Setting reply-to address
echo "Email body" | mail -s "Subject" \
    -a "From: [email protected]" \
    -a "Reply-To: [email protected]" \
    [email protected]

Sending Emails with Attachments

# Send file as attachment
echo "Please find attached report" | mail -s "Daily Report" \
    -A /path/to/report.pdf \
    [email protected]

# Multiple attachments
echo "Logs attached" | mail -s "Server Logs" \
    -A /var/log/syslog.gz \
    -A /var/log/auth.log.gz \
    [email protected]

# Attachment with custom filename
echo "Report attached" | mail -s "Report" \
    -a /path/to/file.txt \
    [email protected]

CC and BCC Recipients

# CC (Carbon Copy)
echo "Email body" | mail -s "Subject" \
    -c "[email protected]" \
    [email protected]

# BCC (Blind Carbon Copy)
echo "Email body" | mail -s "Subject" \
    -b "[email protected]" \
    [email protected]

# Both CC and BCC
echo "Email body" | mail -s "Subject" \
    -c "[email protected]" \
    -b "[email protected]" \
    [email protected]

Advanced Email Formatting

Multi-line Email Bodies

# Using heredoc
mail -s "Multi-line Message" [email protected] <<EOF
This is line 1
This is line 2
This is line 3

Best regards,
System Administrator
EOF

From script:

#!/bin/bash

RECIPIENT="[email protected]"
SUBJECT="System Report"

mail -s "$SUBJECT" "$RECIPIENT" <<EOF
System Monitoring Report
Date: $(date)
Hostname: $(hostname)

Status: All systems operational

Details:
- CPU Usage: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')
- Memory: $(free -h | grep Mem: | awk '{print $3 "/" $2}')
- Disk: $(df -h / | tail -1 | awk '{print $5}')

Automated monitoring system
EOF

HTML Emails

#!/bin/bash
# send-html-email.sh - Send HTML formatted email

RECIPIENT="[email protected]"
SUBJECT="HTML Report"

# Create HTML content
HTML_CONTENT=$(cat <<'EOF'
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        .header { background-color: #4CAF50; color: white; padding: 10px; }
        .content { padding: 20px; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #4CAF50; color: white; }
        .warning { color: #ff9800; }
        .error { color: #f44336; }
    </style>
</head>
<body>
    <div class="header">
        <h2>System Monitoring Report</h2>
    </div>
    <div class="content">
        <p><strong>Server:</strong> server.example.com</p>
        <p><strong>Date:</strong> $(date)</p>

        <h3>System Status</h3>
        <table>
            <tr>
                <th>Metric</th>
                <th>Value</th>
                <th>Status</th>
            </tr>
            <tr>
                <td>CPU Usage</td>
                <td>45%</td>
                <td>OK</td>
            </tr>
            <tr>
                <td>Memory Usage</td>
                <td class="warning">82%</td>
                <td>Warning</td>
            </tr>
            <tr>
                <td>Disk Usage</td>
                <td>65%</td>
                <td>OK</td>
            </tr>
        </table>
    </div>
</body>
</html>
EOF
)

# Send HTML email
echo "$HTML_CONTENT" | mail -s "$SUBJECT" \
    -a "Content-Type: text/html" \
    "$RECIPIENT"

Formatted Tables in Plain Text

#!/bin/bash
# Send formatted table email

{
    echo "System Resource Report"
    echo "======================"
    echo ""
    printf "%-20s %-10s %-10s\n" "Resource" "Usage" "Status"
    printf "%-20s %-10s %-10s\n" "--------" "-----" "------"
    printf "%-20s %-10s %-10s\n" "CPU" "45%" "OK"
    printf "%-20s %-10s %-10s\n" "Memory" "82%" "WARNING"
    printf "%-20s %-10s %-10s\n" "Disk /" "65%" "OK"
    echo ""
    echo "Generated: $(date)"
} | mail -s "Resource Report" [email protected]

Monitoring Script Integration

CPU Monitoring Alert

#!/bin/bash
# cpu-alert.sh - Alert on high CPU usage

CPU_THRESHOLD=80
RECIPIENT="[email protected]"
HOSTNAME=$(hostname)

# Get CPU usage
CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
CPU_USAGE_INT=${CPU_USAGE%.*}

if [ "$CPU_USAGE_INT" -gt "$CPU_THRESHOLD" ]; then
    {
        echo "High CPU usage detected on $HOSTNAME"
        echo "Current usage: ${CPU_USAGE}%"
        echo "Threshold: ${CPU_THRESHOLD}%"
        echo "Time: $(date)"
        echo ""
        echo "Top CPU consumers:"
        ps aux --sort=-%cpu | head -n 11
        echo ""
        echo "Load average:"
        uptime
    } | mail -s "ALERT: High CPU on $HOSTNAME" "$RECIPIENT"

    echo "[$(date)] CPU alert sent" >> /var/log/monitoring/alerts.log
fi

Disk Space Alert

#!/bin/bash
# disk-alert.sh - Alert on low disk space

DISK_THRESHOLD=85
RECIPIENT="[email protected]"
HOSTNAME=$(hostname)

# Check all mounted filesystems
df -h | tail -n +2 | while read filesystem size used avail percent mountpoint; do
    usage=${percent%\%}

    if [ "$usage" -gt "$DISK_THRESHOLD" ]; then
        {
            echo "Low disk space alert on $HOSTNAME"
            echo "Mount point: $mountpoint"
            echo "Usage: $percent"
            echo "Available: $avail"
            echo "Threshold: ${DISK_THRESHOLD}%"
            echo "Time: $(date)"
            echo ""
            echo "Largest directories:"
            du -h "$mountpoint" 2>/dev/null | sort -rh | head -n 10
            echo ""
            echo "Full disk usage:"
            df -h
        } | mail -s "ALERT: Low Disk Space on $HOSTNAME ($mountpoint)" "$RECIPIENT"

        echo "[$(date)] Disk alert sent for $mountpoint" >> /var/log/monitoring/alerts.log
    fi
done

Service Monitoring Alert

#!/bin/bash
# service-alert.sh - Alert when service is down

SERVICE="nginx"
RECIPIENT="[email protected]"
HOSTNAME=$(hostname)

if ! systemctl is-active --quiet "$SERVICE"; then
    {
        echo "Service $SERVICE is DOWN on $HOSTNAME"
        echo "Time: $(date)"
        echo ""
        echo "Service Status:"
        systemctl status "$SERVICE" --no-pager
        echo ""
        echo "Recent Logs:"
        journalctl -u "$SERVICE" -n 50 --no-pager
        echo ""
        echo "Attempting automatic restart..."
    } | mail -s "CRITICAL: $SERVICE down on $HOSTNAME" "$RECIPIENT"

    # Attempt to restart service
    if systemctl start "$SERVICE"; then
        {
            echo "Service $SERVICE has been automatically restarted on $HOSTNAME"
            echo "Time: $(date)"
            echo ""
            echo "Current Status:"
            systemctl status "$SERVICE" --no-pager
        } | mail -s "INFO: $SERVICE restarted on $HOSTNAME" "$RECIPIENT"
    else
        {
            echo "FAILED to restart $SERVICE on $HOSTNAME"
            echo "Manual intervention required!"
            echo "Time: $(date)"
        } | mail -s "CRITICAL: Failed to restart $SERVICE on $HOSTNAME" "$RECIPIENT"
    fi
fi

Security Alert - Failed Login Attempts

#!/bin/bash
# failed-login-alert.sh - Alert on multiple failed login attempts

THRESHOLD=5
RECIPIENT="[email protected]"
HOSTNAME=$(hostname)
LOG_FILE="/var/log/auth.log"  # Use /var/log/secure on CentOS/Rocky

# Count recent failed attempts (last hour)
FAILED_COUNT=$(grep "Failed password" "$LOG_FILE" | \
    grep "$(date -d '1 hour ago' '+%b %d %H')" | wc -l)

if [ "$FAILED_COUNT" -gt "$THRESHOLD" ]; then
    {
        echo "Multiple failed login attempts detected on $HOSTNAME"
        echo "Count: $FAILED_COUNT in the last hour"
        echo "Threshold: $THRESHOLD"
        echo "Time: $(date)"
        echo ""
        echo "Failed attempts by IP:"
        grep "Failed password" "$LOG_FILE" | \
            grep "$(date -d '1 hour ago' '+%b %d %H')" | \
            awk '{print $(NF-3)}' | sort | uniq -c | sort -rn
        echo ""
        echo "Failed attempts by username:"
        grep "Failed password" "$LOG_FILE" | \
            grep "$(date -d '1 hour ago' '+%b %d %H')" | \
            awk '{print $(NF-5)}' | sort | uniq -c | sort -rn
        echo ""
        echo "Recent failed attempts:"
        grep "Failed password" "$LOG_FILE" | tail -20
    } | mail -s "SECURITY: Failed login attempts on $HOSTNAME" "$RECIPIENT"
fi

Comprehensive Monitoring Alert System

Multi-Check Monitoring Script

#!/bin/bash
# comprehensive-alert.sh - Complete monitoring with alerts

# Configuration
RECIPIENT="[email protected]"
HOSTNAME=$(hostname)
LOG_FILE="/var/log/monitoring/alerts.log"

# Thresholds
CPU_THRESHOLD=80
MEM_THRESHOLD=85
DISK_THRESHOLD=90
LOAD_THRESHOLD=2.0

# Alert tracking
ALERTS=()

# Logging function
log_alert() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}

# Check CPU
check_cpu() {
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    local cpu_int=${cpu_usage%.*}

    if [ "$cpu_int" -gt "$CPU_THRESHOLD" ]; then
        ALERTS+=("High CPU usage: ${cpu_usage}% (threshold: ${CPU_THRESHOLD}%)")
        log_alert "CPU alert triggered: ${cpu_usage}%"
    fi
}

# Check Memory
check_memory() {
    local total=$(free -m | grep Mem: | awk '{print $2}')
    local used=$(free -m | grep Mem: | awk '{print $3}')
    local percent=$(echo "scale=2; ($used / $total) * 100" | bc)
    local percent_int=${percent%.*}

    if [ "$percent_int" -gt "$MEM_THRESHOLD" ]; then
        ALERTS+=("High memory usage: ${percent}% (threshold: ${MEM_THRESHOLD}%)")
        log_alert "Memory alert triggered: ${percent}%"
    fi
}

# Check Disk
check_disk() {
    while IFS= read -r line; do
        local mountpoint=$(echo "$line" | awk '{print $6}')
        local percent=$(echo "$line" | awk '{print $5}' | tr -d '%')

        if [ "$percent" -gt "$DISK_THRESHOLD" ]; then
            ALERTS+=("High disk usage on $mountpoint: ${percent}% (threshold: ${DISK_THRESHOLD}%)")
            log_alert "Disk alert triggered for $mountpoint: ${percent}%"
        fi
    done < <(df -h | tail -n +2 | grep -v "tmpfs")
}

# Check Load Average
check_load() {
    local load_1min=$(cat /proc/loadavg | awk '{print $1}')
    local cpu_cores=$(nproc)
    local load_per_core=$(echo "scale=2; $load_1min / $cpu_cores" | bc)

    if (( $(echo "$load_per_core > $LOAD_THRESHOLD" | bc -l) )); then
        ALERTS+=("High load average: $load_per_core per core (threshold: $LOAD_THRESHOLD)")
        log_alert "Load average alert triggered: $load_per_core"
    fi
}

# Check Services
check_services() {
    local services=("nginx" "mysql" "redis")

    for service in "${services[@]}"; do
        if ! systemctl is-active --quiet "$service" 2>/dev/null; then
            if systemctl list-unit-files | grep -q "^${service}.service"; then
                ALERTS+=("Service $service is not running")
                log_alert "Service alert triggered: $service down"
            fi
        fi
    done
}

# Generate and send alert email
send_alerts() {
    if [ ${#ALERTS[@]} -eq 0 ]; then
        return 0
    fi

    {
        echo "System Alert Report for $HOSTNAME"
        echo "=================================="
        echo "Time: $(date)"
        echo "Alert Count: ${#ALERTS[@]}"
        echo ""
        echo "ALERTS:"
        for alert in "${ALERTS[@]}"; do
            echo "  - $alert"
        done
        echo ""
        echo "System Status:"
        echo "--------------"
        echo "CPU Usage: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')"
        echo "Memory: $(free -h | grep Mem: | awk '{print $3 "/" $2}')"
        echo "Load Average: $(cat /proc/loadavg | awk '{print $1, $2, $3}')"
        echo ""
        echo "Disk Usage:"
        df -h | grep -v "tmpfs"
        echo ""
        echo "Top Processes:"
        ps aux --sort=-%cpu | head -n 6
        echo ""
        echo "=================================="
        echo "Automated monitoring system"
    } | mail -s "ALERT: ${#ALERTS[@]} issue(s) on $HOSTNAME" "$RECIPIENT"

    log_alert "Alert email sent to $RECIPIENT"
}

# Main execution
main() {
    log_alert "Starting monitoring checks"

    check_cpu
    check_memory
    check_disk
    check_load
    check_services

    send_alerts

    if [ ${#ALERTS[@]} -gt 0 ]; then
        log_alert "Monitoring completed with ${#ALERTS[@]} alerts"
        exit 1
    else
        log_alert "Monitoring completed - all checks passed"
        exit 0
    fi
}

main

Email Alert Best Practices

Preventing Alert Fatigue

Implement Alert Throttling:

#!/bin/bash
# throttled-alert.sh - Prevent duplicate alerts within timeframe

ALERT_TYPE="$1"
COOLDOWN_MINUTES=60
STATE_DIR="/var/lib/monitoring/alerts"

mkdir -p "$STATE_DIR"

# Check if alert was recently sent
if [ -f "$STATE_DIR/$ALERT_TYPE" ]; then
    LAST_ALERT=$(cat "$STATE_DIR/$ALERT_TYPE")
    CURRENT_TIME=$(date +%s)
    TIME_DIFF=$((CURRENT_TIME - LAST_ALERT))
    COOLDOWN_SECONDS=$((COOLDOWN_MINUTES * 60))

    if [ "$TIME_DIFF" -lt "$COOLDOWN_SECONDS" ]; then
        echo "Alert throttled - sent $(( (COOLDOWN_SECONDS - TIME_DIFF) / 60 )) minutes ago"
        exit 0
    fi
fi

# Send alert and update timestamp
send_alert_function  # Your alert function here

echo "$(date +%s)" > "$STATE_DIR/$ALERT_TYPE"

Alert Severity Levels

#!/bin/bash
# severity-alerts.sh - Different alerts for different severity levels

send_alert() {
    local severity=$1
    local subject=$2
    local message=$3

    case "$severity" in
        CRITICAL)
            # Send to multiple recipients with urgent flag
            echo "$message" | mail -s "CRITICAL: $subject" \
                -a "Importance: high" \
                -a "Priority: urgent" \
                [email protected],[email protected]
            # Also send SMS via email gateway
            echo "$message" | mail -s "$subject" [email protected]
            ;;
        WARNING)
            # Send to admin only
            echo "$message" | mail -s "WARNING: $subject" [email protected]
            ;;
        INFO)
            # Send daily digest instead of immediate
            echo "$message" >> /var/log/monitoring/daily-digest.log
            ;;
    esac
}

# Usage
send_alert "CRITICAL" "Service Down" "Nginx is not responding"
send_alert "WARNING" "High CPU" "CPU usage at 85%"
send_alert "INFO" "Backup Complete" "Daily backup finished successfully"

Daily Summary Reports

#!/bin/bash
# daily-summary.sh - Send daily summary instead of individual emails

SUMMARY_FILE="/var/log/monitoring/daily-summary-$(date +%Y%m%d).log"
RECIPIENT="[email protected]"

# Throughout the day, append to summary file
echo "[$(date)] Event: $EVENT_DESCRIPTION" >> "$SUMMARY_FILE"

# At end of day (via cron), send summary
send_daily_summary() {
    if [ ! -f "$SUMMARY_FILE" ]; then
        return
    fi

    {
        echo "Daily Summary Report"
        echo "===================="
        echo "Date: $(date +%Y-%m-%d)"
        echo "Hostname: $(hostname)"
        echo ""
        echo "Events:"
        cat "$SUMMARY_FILE"
        echo ""
        echo "System Status:"
        echo "CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')"
        echo "Memory: $(free -h | grep Mem: | awk '{print $3 "/" $2}')"
        echo "Disk: $(df -h / | tail -1 | awk '{print $5}')"
    } | mail -s "Daily Summary: $(hostname)" "$RECIPIENT"

    # Archive summary
    mv "$SUMMARY_FILE" "/var/log/monitoring/archive/"
}

# Run this via cron at 11:59 PM
# 59 23 * * * /path/to/daily-summary.sh

Troubleshooting Email Delivery

Test Email Delivery

#!/bin/bash
# test-email.sh - Comprehensive email delivery test

echo "Testing email delivery..."

# Test 1: Basic mail command
echo "Test 1: Basic email" | mail -s "Test Email" [email protected]
echo "Sent test email"

# Test 2: Check mail queue
echo ""
echo "Mail queue:"
mailq

# Test 3: Check Postfix status
echo ""
echo "Postfix status:"
systemctl status postfix --no-pager

# Test 4: Check mail logs
echo ""
echo "Recent mail log entries:"
sudo tail -20 /var/log/mail.log  # or /var/log/maillog on CentOS

# Test 5: Verify SMTP connection
echo ""
echo "Testing SMTP connection:"
telnet smtp.gmail.com 587

Common Issues and Solutions

Issue 1: Mail not being delivered

# Check mail queue
mailq

# View detailed queue
sudo postqueue -p

# Check mail logs
sudo tail -f /var/log/mail.log

# Force queue processing
sudo postfix flush

Issue 2: Authentication failure

# Check SASL configuration
sudo postconf -n | grep sasl

# Verify password file
sudo cat /etc/postfix/sasl_passwd

# Check authentication in logs
sudo grep "authentication failed" /var/log/mail.log

# Test SASL authentication
sudo testsaslauthd -u username -p password

Issue 3: Emails going to spam

# Check SPF record
dig example.com TXT

# Verify DKIM
sudo opendkim-testkey -d example.com -s default

# Check reverse DNS
dig -x YOUR_IP_ADDRESS

# Test email deliverability
# Send test email and check headers
mail -s "Deliverability Test" -v [email protected] < /dev/null

Conclusion

Email alerts with mailx provide a reliable, lightweight, and flexible notification system for Linux server monitoring. By integrating mailx with monitoring scripts, you create an active alerting infrastructure that ensures critical events never go unnoticed.

Key takeaways:

1. Simple but powerful - mailx offers extensive functionality with minimal configuration
2. Integration flexibility - Works seamlessly with shell scripts, cron jobs, and monitoring tools
3. SMTP options - Configure with local MTA or external SMTP services like Gmail or SendGrid
4. Alert management - Implement throttling, severity levels, and daily digests to prevent alert fatigue
5. Customization - Create HTML emails, attach files, and format messages for maximum clarity

Best practices for production alerting:

• Implement alert throttling to prevent notification spam
• Use severity levels to prioritize different types of alerts
• Create clear, actionable alert messages with context
• Test email delivery regularly
• Monitor the monitoring system itself
• Document alert procedures and response protocols
• Use daily summaries for non-critical information
• Ensure proper SPF, DKIM, and reverse DNS configuration

While email alerts remain a cornerstone of monitoring infrastructure, consider complementing them with other notification channels like SMS, Slack, PagerDuty, or webhook integrations for critical alerts requiring immediate attention. A multi-channel approach ensures alerts reach administrators regardless of circumstances, maximizing system uptime and operational efficiency.