Prerequisites

• You have Internet or Ethernet access
• Your host is running Linux or Windows

Installing the Windows Exporter from Prometheus Community GitHub onto a Windows Host

1. Download the latest version from GitHub

• Go to https://github.com/prometheus-community/windows_exporter
• Look for the latest release and download the amd64.msi file

2. Run the installer

• In the initial Custom Setup section, choose Entire feature will be installed on local hard drive under Firewall Exception. This will add an inbound permission for the Exporter listening port.

• Click all the options that say Next or Proceed in the installer
  • You do not need to change or add any other information to use the Prometheus Wizard in Nagios XI, you can simply keep the defaults.

• It will say it is installed
• (Optional): Confirm it is up and running by entering http://<HOST_IP>:9182/metrics

With all the above steps completed, your Windows system is now properly configured for Prometheus monitoring, and you’re ready to move on to integrating it with Nagios XI.

Installing and Running the Prometheus Node Exporter on a Linux Host

1. Download the latest version using command line

• Go to https://prometheus.io/docs/guides/node-exporter/
• Right click the Linux download link and select Copy Link to get exactly what you need to enter in the below wget command.
• On your Linux host, open the terminal
• Run the following command:
  

# wget https://github.com/prometheus/node_exporter/releases/download/v<VERSION>/node_exporter-<VERSION>.<OS>-<ARCH>.tar.gz

This will download the Node Exporter to your Linux host.

2. Run Node Explorer

• Run the following commands:
  • tar xvfz node_exporter-*.*-amd64.tar.gz
  • cd node_exporter-*.*-amd64
  • ./node_exporter

With these above steps completed, your Linux host is ready for Prometheus monitoring, and we are ready to move on to integrating with Nagios XI.

Conclusion

With this, we’ve set it up the data exporters and are ready to configure monitoring in Nagios XI, enabling us to gather all of the same data the same way that Prometheus does, giving us access to the detailed information it provides while showing the data in XI in a clear way.

Monitoring website performance is crucial for ensuring high availability and optimal user experience. Slow response times can lead to lost customers and impact business reputation. In this guide, we introduce a custom Nagios XI plugin that monitors website response times and alerts administrators when predefined thresholds are exceeded.

The Need for Website Response Time Monitoring

Website response time is a key performance metric that reflects how quickly a site responds to user requests. High latency may indicate issues such as server overload, network congestion, or backend inefficiencies. By integrating our custom check_response_time plugin into Nagios XI, administrators can:

• Monitor website uptime and response times
• Set warning and critical thresholds for response time alerts
• Receive real-time notifications when performance degrades

Plugin Overview

Our check_response_time plugin is written in Python and utilizes the requests library to fetch a webpage and measure its response time. It classifies the results into three states:

• OK: Response time is within acceptable limits
• WARNING: Response time exceeds the warning threshold
• CRITICAL: Response time exceeds the critical threshold

Additionally, it handles common network errors, ensuring reliable monitoring.

Plugin Code

Below is the Python code for the Nagios XI plugin:

#!/usr/bin/env python3<br><br>import sys<br>import requests<br>import argparse<br><br>def check_website_health(url, warning_threshold, critical_threshold):<br>    try:<br>        response = requests.get(url, timeout=10)<br>        load_time = response.elapsed.total_seconds() * 1000  # convert to milliseconds<br><br>        if response.status_code != 200:<br>            return (2, f"Website is down. Status Code: {response.status_code}")<br><br>        if load_time >= critical_threshold:<br>            return (2, f"CRITICAL - Response time {load_time:.2f} ms exceeds critical threshold of {critical_threshold} ms")<br>        elif load_time >= warning_threshold:<br>            return (1, f"WARNING - Response time {load_time:.2f} ms exceeds warning threshold of {warning_threshold} ms")<br>        else:<br>            return (0, f"OK - Response time {load_time:.2f} ms")<br>    except requests.exceptions.RequestException as e:<br>        return (3, f"Error checking website: {str(e)}")<br><br>def main():<br>    parser = argparse.ArgumentParser(description="Check website response time")<br>    parser.add_argument("-H", "--host", required=True, help="Host URL")<br>    parser.add_argument("-w", "--warning", type=int, required=True, help="Warning threshold in ms")<br>    parser.add_argument("-c", "--critical", type=int, required=True, help="Critical threshold in ms")<br>    args = parser.parse_args()<br><br>    url = args.host<br>    if not url.startswith('http://') and not url.startswith('https://'):<br>        url = 'http://' + url<br><br>    status, message = check_website_health(url, args.warning, args.critical)<br>    print(message)<br>    sys.exit(status)<br><br>if __name__ == '__main__':<br>    main()

#!/usr/bin/env python3<br><br>import sys<br>import requests<br>import argparse<br><br>def check_website_health(url, warning_threshold, critical_threshold):<br>    try:<br>        response = requests.get(url, timeout=10)<br>        load_time = response.elapsed.total_seconds() * 1000  # convert to milliseconds<br><br>        if response.status_code != 200:<br>            return (2, f"Website is down. Status Code: {response.status_code}")<br><br>        if load_time >= critical_threshold:<br>            return (2, f"CRITICAL - Response time {load_time:.2f} ms exceeds critical threshold of {critical_threshold} ms")<br>        elif load_time >= warning_threshold:<br>            return (1, f"WARNING - Response time {load_time:.2f} ms exceeds warning threshold of {warning_threshold} ms")<br>        else:<br>            return (0, f"OK - Response time {load_time:.2f} ms")<br>    except requests.exceptions.RequestException as e:<br>        return (3, f"Error checking website: {str(e)}")<br><br>def main():<br>    parser = argparse.ArgumentParser(description="Check website response time")<br>    parser.add_argument("-H", "--host", required=True, help="Host URL")<br>    parser.add_argument("-w", "--warning", type=int, required=True, help="Warning threshold in ms")<br>    parser.add_argument("-c", "--critical", type=int, required=True, help="Critical threshold in ms")<br>    args = parser.parse_args()<br><br>    url = args.host<br>    if not url.startswith('http://') and not url.startswith('https://'):<br>        url = 'http://' + url<br><br>    status, message = check_website_health(url, args.warning, args.critical)<br>    print(message)<br>    sys.exit(status)<br><br>if __name__ == '__main__':<br>    main()

You can access the code on Github: Here

How to Use the Plugin in Nagios XI

1. Upload the Plugin to Nagios XI

1. Log in to the Nagios XI Web Interface.
2. Navigate to Admin > System Extensions > Manage Plugins.
3. Click Browse, select the script file, and click Upload & Install.

2. Define the Plugin as a Nagios XI Command

1. Go to Configure > Core Config Manager > Commands > Add New.
2. Enter the following details:
   • Command Name
   • Command Line
   • Command Type: check command

3. Configure a Nagios XI Service

1. Navigate to Configure > Core Config Manager > Services > Add New.
2. Fill in the required fields:
   • Service Name
   • Host: Select the target host
   • Check Command
   • *In this example, a WARNING alert is triggered if the response time exceeds 500ms, and a CRITICAL alert is triggered if it exceeds 1000ms.
3. Configure the Check Settings and Alert Settings.
4. Save the service and apply the configuration.

Testing the Plugin

Conclusion

By integrating the check_response_time plugin into Nagios XI, administrators gain real-time insights into website performance and uptime. This proactive approach helps mitigate potential downtime and ensures a seamless user experience.

Try deploying this plugin in your Nagios XI setup today and take control of your website performance monitoring!

1. Resource Management – Since you only install the plugins you need; you can avoid unnecessary resource usage that would come with more comprehensive software packages.

2. Enhanced Functionality – Plugins add new features and capabilities to existing software without needing to modify the core program. This allows you to expand what your software can do.

3. Customization – You can pick and choose exactly which additional features you want, creating a personalized setup that matches your specific needs rather than dealing with bloated software.

4. Cost-Effective – Instead of buying entirely new software, you can often just add the specific functionality you need through plugins, which are typically less expensive or even free.

5. Easy Updates – Plugins can be updated independently from the main software, making it easier to maintain and improve specific features without affecting the whole system.

6. Development Efficiency – For developers, plugins provide a way to extend applications without having to rebuild them from scratch. The modular nature makes maintenance and debugging easier.

7. Community Innovation – Popular software often has a vibrant plugin ecosystem where developers create innovative solutions for specific needs, benefiting the entire user community.

The Purpose of a CPU Usage Plugin

The purpose of a “Check CPU Usage” plugin is to monitor the percentage of CPU resources being used by the system. It checks whether the CPU usage is within an acceptable range (e.g., below 80%), and alerts if it crosses a threshold, indicating that the system is under heavy load.

Typically, the plugin will return one of the following statuses:

• OK (Exit Code 0): CPU usage is within acceptable limits.
• WARNING (Exit Code 1): CPU usage is above normal but below the critical threshold.
• CRITICAL (Exit Code 2): CPU usage is too high, and action should be taken.
• UNKNOWN (Exit Code 3): The plugin encountered an error, and it could not determine the CPU usage.

How it Works

This script checks how much disk space is being used on your system’s root drive (“/”) and compares it to two important thresholds: warning and critical.

• Warning Threshold (80%): This is the point at which the disk usage is high enough to warn you, but it’s not critical yet.
• Critical Threshold (90%): This is the point at which the disk usage is so high that it’s considered an urgent issue.

Based on the disk usage, the script will return one of three possible results:

OK (if disk usage is below 80%)

CRITICAL (if disk usage is 90% or higher)

WARNING (if disk usage is between 80% and 90%)

Breaking it Down

Line 1: #!/bin/bash

• This tells the system to run this script using bash, a common scripting language.

Line 3-4: Set Thresholds

• WARNING_THRESHOLD=80 and CRITICAL_THRESHOLD=90: The script sets two thresholds — 80% for warning and 90% for critical. These numbers are used to compare against the current disk usage.

Line 6: Get Disk Usage

• USAGE=$(df / | tail -n 1 | awk '{print $5}' | sed 's/%//')
• This command checks the disk usage of the root directory (/).
  • df / gets the disk space details.
  • tail -n 1 picks the last line of output (which contains the disk usage).
  • awk '{print $5}' extracts the disk usage percentage.
  • sed 's/%//' removes the “%” symbol from the usage number.

Line 9-16: Compare Disk Usage to Thresholds

• The script then checks if the disk usage ($USAGE) is above the thresholds:
  • If disk usage is 90% or more: it prints a CRITICAL message, along with performance data, and exits with code 2 (to indicate a critical issue).
  • If disk usage is between 80% and 90%: it prints a WARNING message, along with performance data, and exits with code 1.
  • If disk usage is less than 80%: it prints an OK message, along with performance data, and exits with code 0 (which means everything is fine).

CPU Usage Code

• The script checks the disk usage percentage on the root filesystem (/).
• It compares this percentage with warning and critical levels.
• Based on the result, it gives a message like “OK”, “WARNING”, or “CRITICAL”.
• It also outputs performance data to Nagios in a format it can understand.

Example Output in Nagios XI

Summary

A “Check CPU Usage” Nagios plugin works by gathering the system’s CPU usage data, comparing it against defined thresholds, and returning an appropriate status and message. By creating this plugin, you can effectively monitor CPU performance on your systems and ensure that administrators are alerted if CPU usage exceeds acceptable limits.

This plugin can be customized with different thresholds, enhanced with more sophisticated checks, or extended to monitor specific processes or resource consumption on the server.

You can access the full code on GitHub: CPU Plugin.

This guide walks you through the steps of building a custom Nagios XI plugin, using a simple script that monitors the last 1-minute load average of the host.

This article will go over these following steps:

• Creating a bash script plugin in the Nagios XI host
  • Includes testing the script
• Adding the script as a Command in Nagios XI
• Using the Command to make a monitoring Service
• Where to find more options for the Service

Step 1: Create a Bash Script Plugin in Nagios XI

In order to write a script in the Nagios XI host, you must first log in using the root user.

Use the following commands to get to the directory that holds all of the plugins for Nagios XI. Nano is a text editor that will be used to make the script.

cd /usr/local/nagios/libexec
nano check_load_average.sh

cd /usr/local/nagios/libexec
nano check_load_average.sh

Now that you are in nano, you can start writing your script. The script below takes in the threshold arguments passed in through the command and sets the variables to those values. Then it compares the load value with the threshold values (critical and warning) and returns a message based on how it compared to the thresholds.

You can find the following code here: https://github.com/NagiosEnterprises/plugins-extra/tree/check_load_average.

#!/bin/bash

# Variables
LOAD_AVG=""
WARN=""
CRIT=""


# Parse arguments
while getopts "w:c:" arg; do
  case $arg in
    w) WARN=${OPTARG} ;;
    c) CRIT=${OPTARG} ;;
  esac
done


# Validate args
if [[-z "$WARN" || -z "$CRIT" ]]; then
  echo "UNKNOWN - Invalid arguments. USAGE: $0 -w <warning_threshold> -c <critical_threshold>"
  echo "w: $WARN c: $CRIT"
  exit 3
fi


# Set load average variable
LOAD_AVG=$(uptime | awk -F 'load average: ' '{print $2}' | cut -d',' -f1)


# Compare with thresholds | give computer readable info for performance graphs
if (( $(echo "$LOAD_AVG > $CRIT" | bc -l) )); then
  echo "CRITICAL - Load Average is $LOAD_AVG in the last minute (threshold: $CRIT) | loadaverage=$LOAD_AVG"
  exit 2
elif (( $(echo "$LOAD_AVG > $WARN" | bc -l) )); then
  echo "WARNING - Load Average is $LOAD_AVG in the last minute (threshold: $WARN) | loadaverage=$LOAD_AVG"
  exit 1
else
  echo "OK - Load Average is $LOAD_AVG in the last minute | loadaverage=$LOAD_AVG"
  exit 0
fi

#!/bin/bash

# Variables
LOAD_AVG=""
WARN=""
CRIT=""


# Parse arguments
while getopts "w:c:" arg; do
  case $arg in
    w) WARN=${OPTARG} ;;
    c) CRIT=${OPTARG} ;;
  esac
done


# Validate args
if [[-z "$WARN" || -z "$CRIT" ]]; then
  echo "UNKNOWN - Invalid arguments. USAGE: $0 -w <warning_threshold> -c <critical_threshold>"
  echo "w: $WARN c: $CRIT"
  exit 3
fi


# Set load average variable
LOAD_AVG=$(uptime | awk -F 'load average: ' '{print $2}' | cut -d',' -f1)


# Compare with thresholds | give computer readable info for performance graphs
if (( $(echo "$LOAD_AVG > $CRIT" | bc -l) )); then
  echo "CRITICAL - Load Average is $LOAD_AVG in the last minute (threshold: $CRIT) | loadaverage=$LOAD_AVG"
  exit 2
elif (( $(echo "$LOAD_AVG > $WARN" | bc -l) )); then
  echo "WARNING - Load Average is $LOAD_AVG in the last minute (threshold: $WARN) | loadaverage=$LOAD_AVG"
  exit 1
else
  echo "OK - Load Average is $LOAD_AVG in the last minute | loadaverage=$LOAD_AVG"
  exit 0
fi

To close nano, use the keys ^X, y, then [Enter]

When you first close the script, you will not have permission to execute it. To get permission use the following commands:

chmod +x /usr/local/nagios/libexec/check_load_average.sh

chmod +x /usr/local/nagios/libexec/check_load_average.sh

To make sure the script is working properly, type in this command and substitute the parameters:

./check_load_average.sh -w <warning_threshold> -c <critical_threshold>

./check_load_average.sh -w <warning_threshold> -c <critical_threshold>

The output could be one of four options. It would appear like this:

# An Unknown Response 
UNKNOWN - Invalid arguments. USAGE: $0 -w <warning_threshold> -c <critical_threshold>

# A Critical Response
CRITICAL - Load Average is 1.26 in the last minute (threshold: .04) | loadaverage=1.26

# A Warning Response
WARNING - Load Average is 0.83 in the last minute (threshold: .3) | loadaverage=0.83

# An OK Response
OK - Load Average is 2.21 in the last minute | loadaverage=2.21

# An Unknown Response 
UNKNOWN - Invalid arguments. USAGE: $0 -w <warning_threshold> -c <critical_threshold>

# A Critical Response
CRITICAL - Load Average is 1.26 in the last minute (threshold: .04) | loadaverage=1.26

# A Warning Response
WARNING - Load Average is 0.83 in the last minute (threshold: .3) | loadaverage=0.83

# An OK Response
OK - Load Average is 2.21 in the last minute | loadaverage=2.21

Step 2: Setting up a Command in Nagios XI

Now that the script is running in the host, the next step is to add it as a command. To do that, go to Core Configuration Manager and go to Commands.

At the top of the Commands page is button, select + Add New.

Fill out the fields. It should look like this after.

Select Save. At the top right of the Command page will be a message saying Apply Configuration. Go through the apply configuration process.

Step 3: Setting Up a Service in Nagios XI

On the side bar, go under Monitoring and select Services.

An easy way to get a new service up and running is to copy an existing service and edit it to fit your needs. To do that, go under actions and select copy on any of services. The copied service will be inactive and unapplied. Select the edit icon under actions to make the changes to fit the plugin.

Change the Config Name and other fields to whatever values you want. Make sure to select Active on the bottom left. The other settings tabs can also be changed to fit specific needs.

At the bottom right of the Common Settings tab, is a Run Check Command button. This can be used to test if the command works as expected before saving the changes.

When the settings are all complete, select Save. A message will appear on the top of the service page saying that changes were made, and you need to Apply Configuration. Follow that process the same as you did with Commands.

Where to Find More Service Settings

On the Home page under Details, select Service Status. This will bring up all the services that are being used.

Find the New Service you just created and select it. The Service Status Detail page will show up with multiple tabs of more settings.

Now you have the steps to make your own Nagios Plugin.

For More Help

For any support related questions please visit the Nagios Support Forums at:

http://support.nagios.com/forum/,

Understanding the Space Weather Plugin

The space weather plugin monitors a variety of solar and space-related phenomena that can impact Earth’s systems, offering critical insights for industries and individuals dependent on satellite communications, aviation, and power grids. It tracks solar flares, geomagnetic storms, radio outages, solar radiation, and coronal mass ejections (CMEs), all of which can disrupt technology and infrastructure. The plugin also measures solar wind speed and density, which influence how the solar wind interacts with Earth’s magnetosphere. Additionally, it monitors magnetic field components like Bt and Bz, aiding in the prediction of space weather disturbances that could affect our planet.

The plugin also uses the Kp index to assess global geomagnetic activity. The 3-day forecast feature provides users with the highest Kp value predicted in the upcoming 3-day period and when it occurs, helping them gauge the intensity of space weather activity. With features like the hemispheric power index for both the northern and southern hemispheres, it allows for region-specific monitoring. Aurora chances are calculated based on current solar activity, giving users further insight into space weather’s impact on Earth’s atmosphere. This tool helps users stay informed, enabling them to make timely decisions and prepare for potential disruptions caused by space weather.

How This Plugin Works

This plugin operates by accessing and processing online data, primarily sourced from NASA and NOAA. The data is typically retrieved from websites that provide JSON-formatted data, which allows the Python script to easily read and extract valuable information. For sources that are not formatted as JSON, the plugin uses a slightly more complex process to parse the data and make it readable for extracting the desired information. Once the data is collected, the plugin evaluates the values to determine if the current conditions are categorized as OK, WARNING, or CRITICAL.

Collecting the Data

The following code snippet demonstrates how the plugin retrieves solar wind speed data:

def check_wind_speed():
    url = "https://services.swpc.noaa.gov/products/solar-wind/plasma-2-hour.json" 
    try:
        response = requests.get(url)
        response.raise_for_status()  # Checks if the request was successful

        data = response.json()
        if not data or len(data) < 2:
            return None

        latest_entry = data[-1]
        wind_speed_value = latest_entry[2]  
        return wind_speed_value
    except requests.exceptions.HTTPError as e:
        print(f"HTTP error occurred: {e}")
    except Exception as e:
        print(f"An error occurred: {e}")
    return wind_speed_value

def check_wind_speed():
    url = "https://services.swpc.noaa.gov/products/solar-wind/plasma-2-hour.json" 
    try:
        response = requests.get(url)
        response.raise_for_status()  # Checks if the request was successful

        data = response.json()
        if not data or len(data) < 2:
            return None

        latest_entry = data[-1]
        wind_speed_value = latest_entry[2]  
        return wind_speed_value
    except requests.exceptions.HTTPError as e:
        print(f"HTTP error occurred: {e}")
    except Exception as e:
        print(f"An error occurred: {e}")
    return wind_speed_value

This function uses the requests module in Python to access a JSON file from NOAA. After confirming a successful connection, it extracts the most recent entry in the JSON file and retrieves the value at index 2, which corresponds to the solar wind speed. Below is an example of the JSON format returned by the API:

[
  [
    "time_tag",
    "density",
    "speed",
    "temperature"
  ],
  [
    "2025-02-06 17:59:00.000",
    "0.55",
    "482.3",
    "252385"
  ]
]

[
  [
    "time_tag",
    "density",
    "speed",
    "temperature"
  ],
  [
    "2025-02-06 17:59:00.000",
    "0.55",
    "482.3",
    "252385"
  ]
]

As shown, the first entry in the JSON file represents the field labels (time, density, speed, and temperature), while the second entry contains the latest data, including the solar wind speed, which is stored at index 2. This structure makes it very easy to extract the required data, allowing it to be compared against the warning and critical thresholds set by the user. By checking the wind speed value against these thresholds, the plugin can quickly determine if the space weather conditions are within acceptable limits or if they require attention.

Processing and Sending Data to Nagios XI

Once the values are collected from the data retrieval function, the next step is to determine the severity of the value and send the result to Nagios XI. The following code snippet demonstrates how the severity is assessed:

if args.wind_speed:
        warning_default = 400
        critical_default = 700
        if args.warning:
            warning_default = args.warning
        if args.critical:
            critical_default = args.critical
        wind_speed = check_wind_speed()
        if wind_speed == None:
            print("Wind speed not found.")
            exit(3)
        elif float(wind_speed) > critical_default:
            print(f"CRITICAL - Solar wind speed is HIGH: {wind_speed} km/s | WindSpeed={wind_speed};{warning_default};{critical_default};;")
            exit(2)
        elif float(wind_speed) > warning_default: 
            print(f"WARNING - Solar wind speed is MILD: {wind_speed} km/s | WindSpeed={wind_speed};{warning_default};{critical_default};;")
            exit(1) 
        else:
            print(f"OK - Solar wind speed is LOW: {wind_speed} km/s | WindSpeed={wind_speed};{warning_default};{critical_default};;")
            exit(0)

if args.wind_speed:
        warning_default = 400
        critical_default = 700
        if args.warning:
            warning_default = args.warning
        if args.critical:
            critical_default = args.critical
        wind_speed = check_wind_speed()
        if wind_speed == None:
            print("Wind speed not found.")
            exit(3)
        elif float(wind_speed) > critical_default:
            print(f"CRITICAL - Solar wind speed is HIGH: {wind_speed} km/s | WindSpeed={wind_speed};{warning_default};{critical_default};;")
            exit(2)
        elif float(wind_speed) > warning_default: 
            print(f"WARNING - Solar wind speed is MILD: {wind_speed} km/s | WindSpeed={wind_speed};{warning_default};{critical_default};;")
            exit(1) 
        else:
            print(f"OK - Solar wind speed is LOW: {wind_speed} km/s | WindSpeed={wind_speed};{warning_default};{critical_default};;")
            exit(0)

The first thing this block of code does is check if the wind speed argument has been passed through. Next, it sets either default values or user-defined values for the warning and critical thresholds, depending on what has been specified. After that, it calls the check_wind_speed() function and compares the value to the defined thresholds within the if statements. Based on the comparison, it sends a message and an exit status code to Nagios XI for interpretation. The last part of the message is separated by a pipe (|), and it is formatted like this: <Value_Name>=<Value>;<Warning_Threshold>;<Critical_Threshold>;;. This format allows Nagios XI to graph the chosen value over time, facilitating the monitoring and alerting of space weather conditions.

How it Looks in Nagios

Now that you understand how the code works, let’s take a look at how it appears in Nagios XI, along with an example of the graphs generated by Nagios:

The space weather plugin offers a wide range of metrics and detection services, allowing you to monitor the specific conditions that best fit your needs. As shown in the images above, all the data is conveniently centralized in one place, making it easier to access than browsing multiple websites. Additionally, it provides visualizations through graphs, enabling you to easily spot trends in space weather activity.

Conclusion

The Nagios space weather plugin offers a powerful solution for monitoring and managing space weather conditions that can impact various technologies and industries. By providing real-time data on solar activity, including solar wind speed, geomagnetic storms, and aurora forecasts, it enables users to stay informed and make proactive decisions. The integration with Nagios XI allows for seamless alerting and graphical representation of key metrics, ensuring that space weather disruptions are quickly identified and addressed. With this plugin, organizations can enhance their preparedness and response to space weather events, safeguarding critical infrastructure and operations.

Install the Plugin

To get started with the plugin, simply visit Nagios Enterprises GitHub repository and download the ZIP file. Once downloaded, open Nagios in your browser, navigate to Admin > System Extensions > Manage Config Wizards, then click Browse and upload the file. This will add the wizard and plugin to your Nagios instance and get you set up to monitor space weather conditions. To learn more about the wizard before using it, press here.

If you’d like to create your own plugin, click the link here for a tutorial using bash, or if you’d prefer a video watch the video below to get a better understanding of how creating and configuring plugins work.

In the digital age, power consumption is a critical aspect of IT infrastructure, especially in data centers. Monitoring power consumption helps ensure operational efficiency, reduces energy costs, and prevents unexpected power-related outages. The Check_Power plugin for Nagios XI is designed to track power consumption in real time, assess its impact, and report any critical deviations. This plugin adds an additional layer of monitoring for organizations looking to keep track of energy use and optimize their IT infrastructure.

In this article, we will walk you through integrating the Check_Power Java plugin with Nagios XI. This plugin fetches data from a power API, calculates the Power Usage Effectiveness (PUE), and sends alerts based on the power consumption and PUE values.

Overview of the Nagios Check Power Plugin

The Check_Power plugin is a Java-based solution that connects to a given power API endpoint, retrieves the current power consumption value, and calculates the PUE for your data center’s efficiency. The plugin categorizes the power consumption status as:

• OK: Power consumption is within acceptable limits.
• WARNING: Power consumption is above average but not critical.
• CRITICAL: Power consumption exceeds safe thresholds, triggering an alert.

The PUE value is also calculated using a fixed formula for energy efficiency in data centers:

PUE = Total Facility Energy / IT Energy

This plugin serves as an essential tool for power monitoring in both smaller and larger IT environments.

How It Works

1. Fetch Power Data: The plugin makes a GET request to the specified power API endpoint and retrieves the power consumption data.
2. Calculate PUE: The plugin calculates the Power Usage Effectiveness (PUE) value based on the total facility energy and IT energy.
3. Evaluate Power Status: The plugin checks the retrieved power consumption and returns an alert status based on defined thresholds (e.g., critical for >1000W, warning for >500W).
4. Alert Reporting: The plugin sends the status message and power consumption details back to Nagios XI for monitoring.

Preview of Nagios XI Power Consumption Plugin Code

import java.io.*;
import java.net.*;

public class Check_Power {

    public static final int OK = 0;
    public static final int WARNING = 1;
    public static final int CRITICAL = 2;
    public static final int UNKNOWN = 3;

    private static final double efficiencyThreshold = 1.5;

    public static void main(String[] args) {
        
        if (args.length != 1) {
            System.err.println("UNKNOWN - Missing power API endpoint URL argument.");
            System.exit(UNKNOWN);
        }

        String powerAPIEndpoint = args[0]; // Get the URL from the command-line argument

        try {
            double powerConsumption = getPowerConsumption(powerAPIEndpoint);
            double pue = calculatePUE();

            String status = checkPowerStatus(powerConsumption);
            String message = String.format("Power consumption: %.2f W | PUE: %.2f", powerConsumption, pue);

            System.out.println(status + " - " + message);
            System.exit(getExitCode(status));

        } catch (Exception e) {
            System.err.println("UNKNOWN - Error: " + e.getMessage());
            System.exit(UNKNOWN);
        }
    }

    private static double getPowerConsumption(String powerAPIEndpoint) throws IOException {
        URL url = new URL(powerAPIEndpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");

        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String inputLine;
        StringBuilder response = new StringBuilder();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

       
        String jsonResponse = response.toString();
        System.out.println("Raw JSON Response: " + jsonResponse);

        return parsePowerConsumption(jsonResponse);
    }

    private static double parsePowerConsumption(String jsonResponse) {
    
        try {
            
            int startIdx = jsonResponse.indexOf(":") + 1;
            int endIdx = jsonResponse.indexOf("}");
            String powerValueString = jsonResponse.substring(startIdx, endIdx).trim();
            return Double.parseDouble(powerValueString);
        } catch (Exception e) {
            System.err.println("Error parsing power consumption: " + e.getMessage());
            return 0.0; 
        }
    }

    private static double calculatePUE() {
        double totalFacilityEnergy = 5000;
        double itEnergy = 3000;
        return totalFacilityEnergy / itEnergy;
    }

    private static String checkPowerStatus(double powerConsumption) {
        if (powerConsumption > 1000) {
            return "CRITICAL";
        } else if (powerConsumption > 500) {
            return "WARNING";
        } else {
            return "OK";
        }
    }

    private static int getExitCode(String status) {
        switch (status) {    
            case "OK":
                return OK;
            case "WARNING":
                return WARNING;
            case "CRITICAL":
                return CRITICAL;
            default:
                return UNKNOWN;
        }
    }
}

import java.io.*;
import java.net.*;

public class Check_Power {

    public static final int OK = 0;
    public static final int WARNING = 1;
    public static final int CRITICAL = 2;
    public static final int UNKNOWN = 3;

    private static final double efficiencyThreshold = 1.5;

    public static void main(String[] args) {
        
        if (args.length != 1) {
            System.err.println("UNKNOWN - Missing power API endpoint URL argument.");
            System.exit(UNKNOWN);
        }

        String powerAPIEndpoint = args[0]; // Get the URL from the command-line argument

        try {
            double powerConsumption = getPowerConsumption(powerAPIEndpoint);
            double pue = calculatePUE();

            String status = checkPowerStatus(powerConsumption);
            String message = String.format("Power consumption: %.2f W | PUE: %.2f", powerConsumption, pue);

            System.out.println(status + " - " + message);
            System.exit(getExitCode(status));

        } catch (Exception e) {
            System.err.println("UNKNOWN - Error: " + e.getMessage());
            System.exit(UNKNOWN);
        }
    }

    private static double getPowerConsumption(String powerAPIEndpoint) throws IOException {
        URL url = new URL(powerAPIEndpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");

        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String inputLine;
        StringBuilder response = new StringBuilder();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

       
        String jsonResponse = response.toString();
        System.out.println("Raw JSON Response: " + jsonResponse);

        return parsePowerConsumption(jsonResponse);
    }

    private static double parsePowerConsumption(String jsonResponse) {
    
        try {
            
            int startIdx = jsonResponse.indexOf(":") + 1;
            int endIdx = jsonResponse.indexOf("}");
            String powerValueString = jsonResponse.substring(startIdx, endIdx).trim();
            return Double.parseDouble(powerValueString);
        } catch (Exception e) {
            System.err.println("Error parsing power consumption: " + e.getMessage());
            return 0.0; 
        }
    }

    private static double calculatePUE() {
        double totalFacilityEnergy = 5000;
        double itEnergy = 3000;
        return totalFacilityEnergy / itEnergy;
    }

    private static String checkPowerStatus(double powerConsumption) {
        if (powerConsumption > 1000) {
            return "CRITICAL";
        } else if (powerConsumption > 500) {
            return "WARNING";
        } else {
            return "OK";
        }
    }

    private static int getExitCode(String status) {
        switch (status) {    
            case "OK":
                return OK;
            case "WARNING":
                return WARNING;
            case "CRITICAL":
                return CRITICAL;
            default:
                return UNKNOWN;
        }
    }
}

You can access the code on Github: https://github.com/NagiosEnterprises/plugins-extra/tree/check_power

Output on Nagios-XI

Integrating the Check Power Plugin into Nagios XI

To integrate the Check_Power plugin with Nagios XI, follow these steps:

1. Upload the Plugin to Nagios XI:
   • Log into the Nagios XI Web Interface.
   • Navigate to Admin > System Extensions > Manage Plugins.
   • Click Browse, select the compiled Check_Power.jar file, and click Upload Plugin.
2. Set Executable Permissions:
   • After uploading, ensure the plugin is executable:

chmod +x /usr/local/nagios/libexec/check_power.jar

chmod +x /usr/local/nagios/libexec/check_power.jar

3. Define the Plugin Command:

Command Line:

Go to Configure > Core Config Manager > Commands > Add New.

Add the following details:

Command Name: check_power

java -jar $USER1$/check_power.jar $HOSTADDRESS$ $ARG1$

java -jar $USER1$/check_power.jar $HOSTADDRESS$ $ARG1$

• Command Type: Check command.

Configure Power Monitoring Service:

• Navigate to Configure > Core Config Manager > Services > Add New.
• Fill in the necessary fields:
  • Service Name: Power Monitoring
  • Host: Select the desired host.
  • Check Command: check_power!http://your-power-api-endpoint.com
• Save the service and apply the configuration.

AI Assistance Acknowledgment

This plugin and article development were assisted by AI, demonstrating how artificial intelligence can streamline IT solutions and inspire innovation. We encourage others to explore AI-driven development to enhance their IT operations.

Why This Plugin is Valuable for IT Security and Monitoring

1. Real-Time Power Consumption Monitoring: Track energy consumption and detect inefficiencies in real-time.
2. Energy Efficiency Reporting: The calculated PUE value provides insight into the efficiency of the entire data center’s energy use.
3. Proactive Alerting: Alerts on power consumption thresholds help prevent potential damage to IT infrastructure.
4. Seamless Integration: Easily integrates with Nagios XI, leveraging its centralized monitoring and alerting system.

Best Practices for Using the Check Power Plugin

1. Set Up Regular Monitoring: Schedule periodic checks to consistently track power usage and avoid unexpected surges.
2. Optimize Energy Consumption: Leverage the PUE value to identify opportunities to improve the energy efficiency of your data center.
3. Integrate with Other IT Management Tools: Combine with other Nagios XI plugins for a comprehensive IT management strategy.

Conclusion: Strengthening Energy Management with the Check_Power Plugin

The Check_Power plugin for Nagios XI is a powerful tool for monitoring power consumption and improving the overall energy efficiency of data centers. By proactively tracking power usage and calculating the PUE, IT teams can enhance their infrastructure’s performance, reduce energy costs, and prevent potential issues before they arise. With easy integration into Nagios XI, this plugin provides an accessible, efficient solution for IT professionals striving for better energy management and sustainability.

Nagios XI is equipped with a variety of wizards and plugins designed to monitor various systems, including operating systems, routers, devices, and websites. While many of these plugins are designed to track different services, none specifically monitor website traffic or track how frequently a website is visited.

Why it was made

This plugin was created to fill that gap. The goal is to monitor how often a website is visited based on response time. Although not every user may need this functionality, there are specific use cases where it can be highly beneficial. For example, marketing teams can use this plugin to assess how frequently their online products are being viewed, while schools or organizations may wish to track how often certain websites are being accessed. The core idea is simple: the more frequently a website is visited, the slower its response time becomes. By monitoring response times, we can infer the frequency of website visits.

Overview of Plugin

This Nagios XI plugin is written in Python and requires minimal setup. The only additional piece of information required from the user is the URL of the website you wish to monitor. Once configured, the plugin tracks website response time and provides insights into its visit frequency.

Nagios XI Website Time Plugin Code

#!/usr/bin/env python3
import sys
import requests
import time
import argparse

'''
This website is to monitor the usage of websites
This is done by measuring the response time
Louie Mattia Jan 2025
'''

parser = argparse.ArgumentParser()

# Add the website name when calling
parser.add_argument( '-H',
                    '--host',
                    required=True,
                    type=str,
                    help='The website that will be checked')

args = parser.parse_args()

# Assign website name as variable fo use
website = args.host

# Set timeout timer (allow the program to give up)
TIMEOUT = 10 # Seconds

# Threshold times for Warning and Critical
### Try to add for editable values in XI later, get this working first
WARN_START = 2
CRIT_START = 5

# Output parameters, defaults for Nagios
# DONT CHANGE, IT WILL NOT WORK OTHERWISE
OK = 0
WARNING = 1
CRITICAL = 2
UNKNOWN = 3

def check_response():
    # Make sure it can grab the time properly
    try:
        start = time.time()
        response = requests.get(website, timeout=TIMEOUT)
        # How long did it take to respond
        response_time = time.time() - start

        # Status code 200 means its reachable
        if response.status_code == 200:
            # At this point, check if the repsonse time is critial
            if response_time >= CRIT_START:
                print(f"Response time {response_time:.2f}s exceeds {CRIT_START}s, this site is busy")
                return CRITICAL
            # If not, is it at the warning?
            elif response_time >= WARN_START:
                print(f"Response time {response_time:.2f}s exceeds {WARN_START}s, this site is getting active")
                return WARNING
            # Looks like its fine if it makes it here
            else:
                print(f"This website is calm for now, response time is {response_time:.2f}")
                return OK
        # If different status code, something is up
        else:
            code = response.status_code
            print(f"Status code returned {code:.2f}")
            return CRITICAL
    except requests.exceptions.RequestException as e:
        print("Website cannot be reached")
        return CRITICAL

if __name__ == "__main__":
        exit = check_response()
        sys.exit(exit)

#!/usr/bin/env python3
import sys
import requests
import time
import argparse

'''
This website is to monitor the usage of websites
This is done by measuring the response time
Louie Mattia Jan 2025
'''

parser = argparse.ArgumentParser()

# Add the website name when calling
parser.add_argument( '-H',
                    '--host',
                    required=True,
                    type=str,
                    help='The website that will be checked')

args = parser.parse_args()

# Assign website name as variable fo use
website = args.host

# Set timeout timer (allow the program to give up)
TIMEOUT = 10 # Seconds

# Threshold times for Warning and Critical
### Try to add for editable values in XI later, get this working first
WARN_START = 2
CRIT_START = 5

# Output parameters, defaults for Nagios
# DONT CHANGE, IT WILL NOT WORK OTHERWISE
OK = 0
WARNING = 1
CRITICAL = 2
UNKNOWN = 3

def check_response():
    # Make sure it can grab the time properly
    try:
        start = time.time()
        response = requests.get(website, timeout=TIMEOUT)
        # How long did it take to respond
        response_time = time.time() - start

        # Status code 200 means its reachable
        if response.status_code == 200:
            # At this point, check if the repsonse time is critial
            if response_time >= CRIT_START:
                print(f"Response time {response_time:.2f}s exceeds {CRIT_START}s, this site is busy")
                return CRITICAL
            # If not, is it at the warning?
            elif response_time >= WARN_START:
                print(f"Response time {response_time:.2f}s exceeds {WARN_START}s, this site is getting active")
                return WARNING
            # Looks like its fine if it makes it here
            else:
                print(f"This website is calm for now, response time is {response_time:.2f}")
                return OK
        # If different status code, something is up
        else:
            code = response.status_code
            print(f"Status code returned {code:.2f}")
            return CRITICAL
    except requests.exceptions.RequestException as e:
        print("Website cannot be reached")
        return CRITICAL

if __name__ == "__main__":
        exit = check_response()
        sys.exit(exit)

You can access the code through Github using this link: https://github.com/NagiosEnterprises/plugins-extra/blob/website_time/website_time.py

Output on Nagios XI

As you can see, it gives us the time it took for the website to respond along with a little message about how often it was visited.

Integrating into Nagios XI

1. Integrate into Nagios XI
   1. Navigate to Admin>System Extensions>Manage Plugins
   2. Click browse, locate the plugin file, and hit upload
2. Define Plugin as Nagios Command
   1. Go to Configure>Core Config Manager>Commands>Add New
   2. Enter the following details
      • Command Name: website_time(or any name you prefer, as long as you can identify the command)
      • Command Line: python3 $USER1$/website_time.py -H https://$HOSTADDRESS$
        • Ensure the https:// prefix is included for the command to work correctly
      • Command Type: Check Command
   3. After filling in the details, save the command.
3. Configure for a service
   1. Go to Configure>Core Config Manager>Services>Add New
   2. Fill in the required fields
      • Service Name: Website Time
      • Host: Any applicable website
      • Check Command: website_time
   3. Save service and apply configuration

AI Assistance Acknowledged

This plugin was developed with the assistance of AI, highlighting how AI can streamline the development process. We encourage developers to leverage AI tools to enhance their IT operations and improve efficiency.

Conclusion

While it doesn’t directly track visits, slower response times can provide valuable insights into how often a website is being accessed. This can be especially useful for organizations wanting to understand traffic patterns or measure the performance impact of high traffic levels. Whether for marketing teams analyzing engagement or IT teams tracking website performance, this plugin helps users gain useful data based on inferred visit frequency, ultimately supporting better decision-making and resource management.

What is Space Weather?

Space weather refers to the environmental conditions in space that can affect Earth and our technology, primarily driven by the activity of the Sun. It encompasses a variety of phenomena, including solar flares, coronal mass ejections (CMEs), solar wind, and geomagnetic storms, all of which are caused by the Sun’s activity.

At the core of space weather are solar emissions, such as energetic particles and radiation, which can be emitted during periods of heightened solar activity, like solar flares or the ejection of large masses of solar material. These solar events can travel through space, impacting the Earth’s magnetosphere and ionosphere. When these high-energy particles interact with Earth’s magnetic field, they can cause geomagnetic storms, disrupting satellite communications, GPS systems, power grids, and even posing risks to astronauts and spacecraft.

In addition to solar emissions, space weather also includes the behavior of the solar wind—a constant stream of charged particles emitted by the Sun. While typically less intense, the solar wind can also affect satellite operations and the behavior of Earth’s magnetosphere. This constant solar activity, though often invisible to the naked eye, can have significant effects on modern technological systems, highlighting the need for vigilant monitoring and understanding of space weather.

Challenges in Predicting Space Weather

Predicting space weather is challenging due to the complex and unpredictable nature of the Sun’s activity. Unlike terrestrial weather, which relies on observable patterns, space weather is driven by solar events like flares and coronal mass ejections (CMEs) that are difficult to predict in terms of timing, location, and intensity. The Sun’s magnetic field is dynamic and not fully understood, adding to the uncertainty.

Additionally, solar events travel through space at varying speeds, making it hard to predict their exact arrival at Earth. While we can observe solar activity and model space weather, the unpredictable behavior of the Sun and Earth’s magnetic field interactions make precise forecasts difficult. Current predictions are often based on trends or probabilities rather than certainty, as researchers continue to improve observation techniques and modeling methods.

Solar storms are typically predicted with certainty only 1 to 3 days before arrival due to the difficulty in forecasting solar flares and CMEs. These events release high-speed particles that take 15 to 90 hours to reach Earth, limiting long-term warnings. While we can detect solar activity as it happens, the variable travel time makes early preparation challenging.

Why Should Space Weather be Monitored?

Space weather is increasingly important to monitor as it has the potential to significantly impact modern technology and human activities. Solar events such as solar flares, coronal mass ejections (CMEs), and variations in solar wind can disrupt communications, damage infrastructure, and pose risks to both space missions and daily life on Earth. Understanding space weather allows for early warnings, enabling mitigation strategies to minimize damage and prevent costly or dangerous disruptions. For more information and updates, you can visit the NOAA Space Weather Prediction Center. Below are key space weather phenomena that highlight the need for constant monitoring.

Geomagnetic Storms

Geomagnetic storms occur when solar wind or a CME interacts with Earth’s magnetosphere, causing disturbances in the magnetic field. These storms can induce electric currents in power lines, leading to transformer damage and widespread power outages. Geomagnetic storms also have the potential to affect satellite orbits, damaging or even disabling satellites, and can cause navigation system failures. Additionally, the storm’s effects on Earth’s ionosphere can disrupt high-frequency radio communications, making global communication difficult.

Radio Blackouts

Radio blackouts occur when solar flares increase in intensity, sending out bursts of electromagnetic radiation that can interfere with radio signals. These blackouts primarily affect high-frequency (HF) radio communications, which are widely used by aviation, maritime, and military operations for long-range communication. Solar flares can cause these radio signals to be absorbed or refracted in the ionosphere, leading to complete loss of communication in certain regions, especially during the peak of a solar flare.

Solar Radiation Storms

Solar radiation storms are characterized by the release of high-energy particles, such as protons and electrons, from the Sun during solar flares or CMEs. These storms pose a serious threat to astronauts and spacecraft, as the particles can damage electronic components and increase radiation exposure, potentially compromising mission safety. At lower altitudes, the effects are less severe, but radiation from solar storms can still disrupt aviation systems, particularly for flights that cross polar regions, where the atmosphere provides less shielding from cosmic radiation.

What is Typically Monitored in Space Weather?

To predict space weather, scientists track several key factors to assess the potential risks of solar events like coronal mass ejections (CMEs) and solar flares. These measurements provide early warnings and help mitigate the effects of solar activity on Earth’s infrastructure.

Solar Activity and Sunspot Cycles

The Sun follows an 11-year solar cycle of high and low activity, marked by the appearance of sunspots. Sunspots indicate increased solar flares and CMEs. Monitoring sunspot activity helps predict periods of heightened solar events.

Coronal Mass Ejections (CMEs)

CMEs are large bursts of solar wind and magnetic fields released from the Sun’s corona. These can take 15-90 hours to reach Earth. CMEs are monitored using spacecraft like SOHO and SDO to track their speed, size, and direction, as they can cause geomagnetic storms that disrupt satellite operations and power grids.

Why CMEs are Dangerous: The magnetic fields carried by CMEs can significantly disturb Earth’s magnetosphere, leading to intense geomagnetic storms that may damage satellites, power systems, and communication infrastructure.

Solar Flares

Solar flares are intense bursts of radiation, monitored using X-ray and UV instruments like the GOES satellites. These flares emit large amounts of radiation that can disrupt satellite communication, GPS systems, and cause radio blackouts, especially on high-frequency radio bands.

Why Solar Flares are Dangerous: Solar flares release radiation that can interfere with electronics, pose risks to astronauts, and disrupt long-range communications.

Solar Wind

Solar wind, a constant stream of charged particles, is monitored to predict solar activity. It can distort Earth’s magnetic field, contributing to geomagnetic storms and affecting satellite systems.

Why Solar Wind is Dangerous: High-intensity solar wind can amplify the effects of CMEs and solar flares, further disrupting communications and satellite operations.

Plasma Density

Plasma density indicates the concentration of charged particles in solar wind and CMEs. Higher plasma density leads to stronger interactions with Earth’s magnetosphere, increasing the potential for geomagnetic storms.

Bz and Bt Components

Bz refers to the solar wind’s magnetic field component along the Sun-Earth axis, while Bt measures the magnetic field in the plane of the solar wind. When Bz points southward, it can cause stronger geomagnetic storms by more easily interacting with Earth’s magnetic field.

Kp Index

The Kp index measures geomagnetic activity on a scale of 0 to 9, with higher values indicating more intense space weather. It helps assess the severity of solar wind and CME impacts, predicting disruptions to satellite communications and power systems.

Hemispheric Power

Hemispheric power tracks the energy released during geomagnetic storms, which is measured in gigawatts. Higher hemispheric power indicates a more intense storm, which can cause significant disruptions to Earth’s infrastructure, including satellites and power grids.

By monitoring these factors—solar activity, CMEs, solar flares, plasma density, Bz/Bt components, and space weather indices like Kp and hemispheric power—scientists can predict and understand the severity of solar events. This information helps prepare for and mitigate potential disruptions to communications, navigation systems, and power grids.

Conclusion

Space weather plays a critical role in shaping the impact on our technological systems and daily lives. As solar activity reaches its maximum, the risks posed by solar flares, CMEs, and other space weather phenomena grow more significant. Monitoring these events is essential to predicting and mitigating their potential impact on everything from communication systems to satellite operations. With advancements in space weather forecasting, we are better equipped to understand and respond to these challenges, but continued vigilance and preparedness are key to minimizing disruptions. By staying informed and proactive, we can better protect our infrastructure and ensure the resilience of modern society.

Start Monitoring Space Weather Using Nagios XI

To start monitoring space weather with Nagios XI, visit the Nagios Enterprises GitHub link provided and download the ZIP file. Once the download is complete, open Nagios in your browser, go to Admin > System Extensions > Manage Config Wizards, then click Browse to upload the file. This will add the wizard and plugin to your Nagios instance, setting you up to monitor space weather conditions.

For a deeper understanding of the plugin and its functionality, click here to read a detailed article. If you’d like more information about the configuration wizard for this plugin, click here.

Nagios XI port monitoring plugin is essential for proactive cybersecurity defense. Monitoring open ports helps prevent unauthorized access and potential cyber threats. While Nagios XI provides powerful monitoring capabilities, integrating a custom Nagios XI port monitoring plugin enhances network security by detecting unexpected open ports before they become vulnerabilities.

This article introduces a lightweight and efficient Bash script that functions as a Nagios XI port monitoring plugin to scan and detect open ports. By adding this custom monitoring solution, IT teams can proactively secure their networks and improve compliance with security policies.

Overview of the Nagios Port Monitoring Plugin

This Nagios XI port monitoring plugin is a Bash script that uses netcat (nc) to scan a target system’s open ports. It accepts two arguments:

• Host/IP Address – The system to be scanned.
• Port Number – The port to check for accessibility.

How It Works

• If the port is open, the script returns a CRITICAL status, triggering an alert in Nagios XI.
• If the port is closed, it returns an OK status, confirming that no risk is detected.

By using this Nagios XI port monitoring plugin, IT teams can detect unauthorized open ports in real time, allowing for quick mitigation of potential security risks.

Nagios XI Port Monitoring Plugin Code

#!/bin/bash
HOST=$1
PORT=$2
if [ -z "$HOST" ] || [ -z "$PORT" ]; then
    echo "Usage: $0  "
    exit 1
fi
# Check if the specific port is open
nc -z -v -w2 $HOST $PORT 2>&1 | grep -q "succeeded"
if [ $? -eq 0 ]; then
    echo "CRITICAL: Port $PORT is open on $HOST"
    exit 2
else
    echo "OK: No open port $PORT detected on $HOST"
    exit 0
fi

You can access the code on Github: https://github.com/NagiosEnterprises/plugins extra/blob/main/port_plugin.sh

Output on Nagios-XI:

Example of a Performance Graph:

Integrating the Plugin into Nagios XI

1. Upload the Plugin to Nagios XI

1. Log in to the Nagios XI Web Interface.
2. Navigate to Admin > System Extensions > Manage Plugins.
3. Click Browse, select the script file, and click Upload Plugin.

chmod +x /usr/local/nagios/libexec/check_port.sh

2. Define the Plugin as a Nagios XI Command

1. Go to Configure > Core Config Manager > Commands > Add New.
2. Enter the following details:
   • Command Name: check_port
   • Command Line:

$USER1$/check_port.sh $HOSTADDRESS$ $ARG1$

• Command Type: check command

3. Click Save Command, then Apply Configuration.

3. Configure a Port Monitoring Service

1. Navigate to Configure > Core Config Manager > Services > Add New.
2. Fill in the required fields:
   • Service Name: Port Monitoring
   • Host: Select the target server.
   • Check Command: check_port!22 (Replace 22 with the desired port number).
3. Save the service and apply the configuration.

AI Assistance Acknowledgment

This plugin and article development were assisted by AI, demonstrating how artificial intelligence can streamline IT solutions and inspire innovation. We encourage others to explore AI-driven development to enhance their IT operations.

Why This Plugin is Valuable for IT Security

• Proactive Security Monitoring – Detects unauthorized open ports before they become security vulnerabilities.
• Firewall and Compliance Verification – Ensures that firewall rules and security policies are effectively enforced.
• Lightweight and Efficient – Uses minimal system resources, making it ideal for continuous monitoring.
• Seamless Integration with Nagios XI – Works within the Nagios XI interface for centralized monitoring and alerting.

This Nagios XI port monitoring plugin is efficient and lightweight, ensuring seamless integration with Nagios XI for enhanced security monitoring.

Best Practices for Using the Nagios XI Port Monitoring Plugin

• Regularly update firewall rules to prevent unauthorized access.
• Schedule frequent scans using the Nagios XI port monitoring plugin to detect unexpected changes in network security
• Use alerts and logs generated by Nagios XI to analyze potential attack patterns.
• Combine with other security tools like intrusion detection systems (IDS) and SIEM solutions for enhanced threat monitoring.

Conclusion: Strengthening Security with the Nagios XI Port Monitoring Plugin

The Nagios XI port monitoring plugin provides a critical security enhancement, allowing IT teams to monitor and secure open ports in real time. By integrating this plugin, organizations can proactively detect potential threats, comply with security policies, and protect their networks from cyberattacks.

By continuously monitoring unexpected open ports, IT teams can strengthen their security posture and mitigate risks before they escalate into major threats. Implementing this Nagios XI port monitoring plugin is a cost-effective and efficient approach to enhancing cybersecurity defenses.

Still need to install Nagios? Follow this guide!

Getting Started with NCPA

First, you’ll need to download and install the Nagios Cross Platform Agent (NCPA) on the Windows machine you want to monitor. NCPA acts as a bridge between your Windows system and Nagios XI, enabling communication and monitoring of various metrics, including custom scripts like the one we’ll be creating. You can download NCPA and access its documentation here.

Using the NCPA Configuration Wizard

After installing NCPA on your Windows machine, the next step is to configure it in Nagios XI using the NCPA Configuration Wizard. Simply enter the IP address of your Windows machine and the token you generated during the NCPA installation, and you’ll be all set to start monitoring.

Creating a Script

You can create any PowerShell script you’d like, but for this example I created a simple script for monitoring the running status and CPU processing time of a program. I used notepad++ to create the script on the windows machine that I am monitoring. You can download the script I used directly from github right here.
Note: Notepad++ will need to be ran as administrator in order to save the script to the plugins folder.

Saving Your Script

Once you have created your script you will save it to C:/Program Files/Nagios/NCPA/plugins folder. Make sure to save the script as a .ps1 PowerShell script.
Note: If you cannot find the ‘Nagios’ folder it may be in Program Files (x86) instead

Testing Your Script

Now that your script has been saved, it is time to test it and make sure it’s free from syntax errors. Open PowerShell on your Windows machine and navigate to your plugins folder that you saved the script to using the cd command to change directory. Before running the script, you’ll need to enable script execution by entering the command: Set-ExecutionPolicy RemoteSigned -Scope CurrentUser. This will allow you to execute the script.

Now you can execute your script by typing ./myscriptname.ps1 and any arguments will be included after. For example, to run my script I did ./checkprocesses2.ps1 msedge -w 500. This lets me check if msedge is running and will generate a warning if it has used over 500 seconds of CPU processing time.

Testing Your Script on Your Nagios XI Server

Once you have confirmed that your script is running correctly, you will test it on the Nagios XI server to make sure that the NCPA API is communicating with Nagios XI correctly. Run the command below to test this, but replace the <> with your own values.

/usr/local/nagios/libexec/check_ncpa.py -H <windows ip> -t <yourtoken> -P 5693 -M 'plugins/<scriptname.ps1>' -a <arguments>

For example this is what I entered:

If you got an output that was not an error you can confirm that NCPA is working as intended!

Adding the Command to Nagios XI

Once you’ve confirmed that everything is working correctly, you’re ready to add your command to Nagios XI. From the homepage, click the gear icon on the left to access the settings menu. Then, navigate to Core Config Manager > Commands and click Add New. This will take you to the Command Management page. Enter a name for your command, and in the Command Line field, input the command below, making sure to replace check_process2.ps1 with the name of your script.

$USER1$/check_ncpa.py -H $HOSTADDRESS$ -t $ARG1$ -P 5693 -M 'plugins/check_process2.ps1' -a $ARG3$

Leave everything else as default, then save and apply the configuration.

Adding the Service to Nagios XI

Now that your command is created, you can set up the service. Return to the gear icon on the left and navigate to Core Config Manager > Services, then click Add New. This will take you to the Service Management page. Enter a configuration name and description.

Next, click Manage Hosts and select the Windows host you added earlier during the NCPA Configuration Wizard setup. Then, under Check Command, select the command you created in the previous step. Be sure to replace each $ARG$ placeholder with the appropriate information. To test the configuration, click Run Check Command at the bottom, and enter the Windows machine’s IP address.

Once you’ve confirmed that the test is successful, you’ll need to complete the required fields in the Check Settings and Alert Settings tabs. Finally, click Save and apply the configuration to finish setting up your service.

Finishing Up

Congratulations! You’ve successfully created a custom Nagios plugin using PowerShell to monitor a specific process on a Windows system. By leveraging the power of NCPA and Nagios XI, you’ve set up seamless monitoring, ensuring that critical applications are being tracked and your servers are running smoothly. With the steps outlined in this article, you can now easily manage and monitor your systems with greater precision.

As you continue to refine your monitoring setup, feel free to experiment with additional scripts and configurations to meet your specific needs. Remember, custom Nagios plugins allow you to tailor the monitoring experience to your environment, providing better insights and more effective alerts. Thanks for following along, and happy monitoring!