Implementing Automated API Status Monitoring for Tomcat Applications#

Monitoring API health and availability is crucial for maintaining reliable web services. This guide demonstrates how to implement an automated API status monitoring solution for Tomcat applications using Bash scripting, providing real-time visibility into your API endpoints’ health.

Understanding the Architecture#

The monitoring system consists of several components working together:

1
graph TD
2
    A[Monitoring Script] --> B[Tomcat Server]
3
    B --> C[Deployed Applications]
4
    A --> D[Status Output JSON]
5
    A --> E[Log File]
6

7
    F[Configuration] --> A
8
    G[System Commands] --> A
9

10
    subgraph "Monitoring Components"
11
        A
12
        D
13
        E
14
        F
15
    end
16

17
    subgraph "Tomcat Environment"
18
        B
19
        C
20
    end

Implementation#

1. Basic Script Structure#

First, create the main script file api-status-monitor.sh:

1
#!/usr/bin/env bash
2
set -euo pipefail
3
IFS=$'\n\t'
4

5
# Configuration
6
readonly SCRIPT_NAME=$(basename "$0")
7
readonly SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
8
readonly LOG_FILE="${SCRIPT_DIR}/${SCRIPT_NAME%.*}.log"
9
readonly CONFIG_FILE="${SCRIPT_DIR}/${SCRIPT_NAME%.*}.conf"
10
readonly DEFAULT_OUTPUT_FILE="/opt/tomcat/api_status.json"
11
readonly DEFAULT_TOMCAT_PORT=8080
12
readonly DEFAULT_TOMCAT_HOST="localhost"
13
readonly DEFAULT_TIMEOUT=5
14

15
# Load configuration if exists
16
[[ -f "$CONFIG_FILE" ]] && source "$CONFIG_FILE"
17

18
# Set defaults if not defined
19
TOMCAT_HOME=${TOMCAT_HOME:-"/opt/tomcat"}
20
OUTPUT_FILE=${OUTPUT_FILE:-$DEFAULT_OUTPUT_FILE}
21
TOMCAT_PORT=${TOMCAT_PORT:-$DEFAULT_TOMCAT_PORT}
22
TOMCAT_HOST=${TOMCAT_HOST:-$DEFAULT_TOMCAT_HOST}
23
TIMEOUT=${TIMEOUT:-$DEFAULT_TIMEOUT}
24

25
# ...existing code...

2. Logging and Command Validation#

Add logging and command validation functions:

1
# ...existing code...
2

3
log() {
4
    local level=$1
5
    shift
6
    echo "$(date +'%Y-%m-%d %H:%M:%S') [$level] $*" >> "$LOG_FILE"
7
    if [[ $level == "ERROR" ]]; then
8
        echo "ERROR: $*" >&2
9
    elif [[ $level != "DEBUG" ]]; then
10
        echo "$*"
11
    fi
12
}
13

14
check_command() {
15
    if ! command -v "$1" &> /dev/null; then
16
        log "ERROR" "$1 is required but not installed. Aborting."
17
        exit 1
18
    fi
19
}
20

21
# Validate required commands
22
for cmd in curl grep find jq timeout; do
23
    check_command "$cmd"
24
done
25

26
# ...existing code...

3. Tomcat Status Checking#

Add functions to check Tomcat status and deployed applications:

1
# ...existing code...
2

3
is_tomcat_running() {
4
    pgrep -f "org.apache.catalina.startup.Bootstrap" > /dev/null
5
    return $?
6
}
7

8
get_deployed_apps() {
9
    find "$TOMCAT_HOME/webapps" -maxdepth 1 \( -type d -o -name "*.war" \) ! -name "webapps" -printf "%f\n"
10
}
11

12
# ...existing code...

4. API Status Checking Logic#

Implement the core API checking functionality:

1
# ...existing code...
2

3
check_api_status() {
4
    local app_name=$1
5
    local app_results=()
6
    local endpoints=("/api" "/rest" "/webservices" "/v1" "/api/v1" "")
7

8
    for endpoint in "${endpoints[@]}"; do
9
        local url="http://$TOMCAT_HOST:$TOMCAT_PORT/$app_name$endpoint"
10
        local curl_output
11

12
        if ! curl_output=$(timeout "$TIMEOUT" curl -o /dev/null -s -w "%{http_code}" "$url" 2>&1); then
13
            log "WARN" "Failed to connect to $url: $curl_output"
14
            continue
15
        }
16

17
        local http_code=$curl_output
18
        local status
19

20
        case $http_code in
21
            2[0-9][0-9]|30[0-8])
22
                status="Working"
23
                ;;
24
            401|403)
25
                status="Protected"
26
                ;;
27
            404|405)
28
                continue
29
                ;;
30
            *)
31
                status="Not working"
32
                ;;
33
        esac
34

35
        app_results+=("{\"path\":\"/$app_name$endpoint\",\"status\":\"$status\",\"code\":$http_code}")
36
    done
37

38
    if [ ${#app_results[@]} -eq 0 ]; then
39
        app_results+=("{\"path\":\"/$app_name\",\"status\":\"No working endpoints\",\"code\":null}")
40
    fi
41

42
    local joined_results
43
    joined_results=$(IFS=,; echo "${app_results[*]}")
44
    echo "\"$app_name\": [$joined_results]"
45
}
46

47
# ...existing code...

5. Main Execution Logic#

Add the main execution function:

1
# ...existing code...
2

3
main() {
4
    log "INFO" "Starting API status check"
5

6
    if ! is_tomcat_running; then
7
        log "ERROR" "Tomcat is not running. Aborting."
8
        echo "{\"error\": \"Tomcat is not running\", \"generated_on\": \"$(date -Iseconds)\"}" > "$OUTPUT_FILE"
9
        exit 1
10
    }
11

12
    local temp_file
13
    temp_file=$(mktemp)
14

15
    echo "{" > "$temp_file"
16
    echo "  \"generated_on\": \"$(date -Iseconds)\"," >> "$temp_file"
17
    echo "  \"tomcat_status\": \"running\"," >> "$temp_file"
18
    echo "  \"apps\": {" >> "$temp_file"
19

20
    local apps
21
    mapfile -t apps < <(get_deployed_apps)
22
    local last_index=$((${#apps[@]} - 1))
23

24
    for i in "${!apps[@]}"; do
25
        app="${apps[$i]}"
26
        result=$(check_api_status "$app")
27
        echo "    $result" >> "$temp_file"
28
        if [ "$i" -ne "$last_index" ]; then
29
            echo "," >> "$temp_file"
30
        fi
31
    done
32

33
    echo "  }" >> "$temp_file"
34
    echo "}" >> "$temp_file"
35

36
    if jq empty "$temp_file" &> /dev/null; then
37
        mv "$temp_file" "$OUTPUT_FILE"
38
        log "INFO" "API status results have been saved to $OUTPUT_FILE"
39
    else
40
        log "ERROR" "Generated JSON is invalid. Check $temp_file for details."
41
        exit 1
42
    }
43
}
44

45
# Run main function
46
main
47
exit 0

6. Configuration File#

Create a configuration file api-status-monitor.conf:

1
# Tomcat configuration
2
TOMCAT_HOME="/opt/tomcat"
3
TOMCAT_PORT=8080
4
TOMCAT_HOST="localhost"
5

6
# Output configuration
7
OUTPUT_FILE="/opt/tomcat/api_status.json"
8

9
# Monitoring configuration
10
TIMEOUT=5

Setting Up the Monitoring System#

1. Installation#

1
# Make script executable
2
sudo chmod +x /usr/local/bin/api-status-monitor.sh
3

4
# Create required directories
5
sudo mkdir -p /opt/tomcat
6
sudo chown tomcat:tomcat /opt/tomcat

2. Cron Job Setup#

Create a cron job to run the script periodically:

1
# Add to root's crontab
2
sudo crontab -e
3

4
# Add the following line to run every 5 minutes
5
*/5 * * * * /usr/local/bin/api-status-monitor.sh

3. Log Rotation#

Configure log rotation to manage the log files:

1
# Create log rotation configuration
2
sudo tee /etc/logrotate.d/api-status-monitor << 'EOF'
3
/usr/local/bin/api-status-monitor.log {
4
    daily
5
    rotate 7
6
    compress
7
    delaycompress
8
    missingok
9
    notifempty
10
    create 640 root root
11
}
12
EOF

Example Output#

The script generates a structured JSON output:

1
{
2
  "generated_on": "2024-07-20T10:15:30+00:00",
3
  "tomcat_status": "running",
4
  "apps": {
5
    "ROOT": [
6
      {
7
        "path": "/ROOT",
8
        "status": "No working endpoints",
9
        "code": null
10
      }
11
    ],
12
    "my-api": [
13
      {
14
        "path": "/my-api/api",
15
        "status": "Working",
16
        "code": 200
17
      },
18
      {
19
        "path": "/my-api/v1",
20
        "status": "Protected",
21
        "code": 401
22
      }
23
    ]
24
  }
25
}

Best Practices and Recommendations#

Error Handling:
- Use strict mode (set -euo pipefail)
- Implement proper logging
- Handle edge cases gracefully
Security:
- Run with appropriate permissions
- Protect sensitive information in logs
- Use secure temporary files
Performance:
- Implement appropriate timeouts
- Use efficient file operations
- Minimize external command calls
Maintenance:
- Keep logs rotated
- Monitor script execution
- Update configurations as needed

Conclusion#

This API status monitoring solution provides real-time visibility into the health of your Tomcat applications. By implementing this script and following the provided best practices, you can ensure reliable monitoring of your API endpoints.