Agent-based G2 Custom Monitors

Using G2 custom monitors, you can build and manage independent monitoring solutions without relying on the platform. Remote Script Executor executes shell, PowerShell, and Python scripts on Linux and Windows workstations.

Key features include:

• User-defined external arguments support the script through custom attributes.
• Monitor level script execution: Ability to pull more metrics in a single script execution.
• Ability to execute different types of scripts through custom script options apart from default options.
• Ability to use credentials attached to the device in the script using the dynamic macro support.

Constraint:

Windows workstation monitoring using a Linux Gateway is not supported.

Step 1: Create metrics

Define metrics metadata that correlates with your script output and matches the monitor you define in the next step.

1. Select a client from the All Clients list.
2. Go to Setup > Monitoring > Metrics.
3. From METRICS, click + Add.
4. From Create Metric, enter the values for the fields described in the following tables and click Save.

Metric specification

[1] See the Metric token reference for a list of the tokens that can be used in the Subject and Description fields.

Step 2: Create a monitor

A custom Remote Script Executor monitor is a collection of Remote Script Executor metrics. You can create a template based on the Remote Script Executor monitor.

Macros are used to pass dynamic arguments to scripts. Use the static and dynamic macros listed in the following tables to make native and custom attributes available to the monitor.

You must create metrics in Step 1: Create metrics before creating a monitor.

1. Select a client from the All Clients list.
2. Go to Setup > Monitoring > Monitors
3. Click + Create New.
4. On the CREATE A MONITOR page, enter the fields listed in the following table and click Save. The newly created monitor is added to the list of monitors.

Monitor specification

Static macros

Use static macros to override the resource values. See the Static macro reference for a list of static macros.

Dynamic macros

You can use a dynamic macro to get custom device attributes. The script custom attribute specification syntax is:

${customattribute.customAttributekey}

For example, if you have a macro defined as ${customattribute.serviceName} in the script, and the device has a custom attribute key-value pair of serviceName:oracledb, the ${customattributes.serviceName} macro is replaced with the value oracledb.

Use a dynamic macro to get device credentials instead of keeping the username and password in plain text form. The macro replaces a credential replacement when the script executes. The general credential syntax is:

${credentials.CredentialName.credentialField}

For example, if you define a credential with name JMXCred on the device, you can use the macro ${credentials.JMXCred.username} to authenticate.

Script execution path for configuration parameters in Linux and Windows

The following runtime executables should be available in your Path variable for the corresponding operating system.

If your runtime is not set as an environment variable, provide the runtime absolute path in custom.script.execution.path. For example, if python is not set, set custom.script.execution.path to /usr/lib/python.

Step 3: Create a template

A template is an instance of a monitor and is applied to devices.

1. Select a client from the All Clients list.
2. Go to Setup > Monitoring >Templates.
3. From Templates, click + Add.
4. From MONITOR TEMPLATE, provide details for the following parameters and click Save.

After adding the template, add component thresholds and component filters by editing metric values. For more information, see Add Filter and Define Threshold

Step 4: Assign a template

1. From the left pane, click Infrastructure. The Infrastructure screen of the selected client is displayed.
2. From the Resources tab, select the required resource from the list of resources. Or, use the search option to find the resource.
3. Click the resource name to view details.
4. From the left pane, click Monitors.
5. From the Templates tab, click +Assign Templates.
6. From Apply Templates, select the templates.
   The selected Templates section displays the chosen templates.
7. Click Assign. The template gets assigned to the selected device.

After assigning the template to a resource for monitoring, click Get Latest Metric Values to view the latest metric information.

Step 5: View graphs

The Agent monitors the system using the assigned templates and displays the results in a graphical format.

1. From the left pane, click Infrastructure.
2. From the Resources tab, select the required resource from the list of resources. Or, use the search option to find the resource.
3. Click the resource name to view details.
4. From the left pane, click Metrics. The Metrics page displays graphs generated by all monitoring templates assigned to a device.
5. Search with the template name to filter the graphs.

Scripts folder and permissions

By default, all the Remote Script Executor (RSE) custom monitor scripts are downloaded to a predefined location in your system. The system user (Windows) and Root/Non-Root User (Linux) hold all the required permissions (Read, Write, and Execute) in the downloaded folders.

The following table provides the default folder locations and users for Windows and Linux:

Script file integrity check

OpsRamp will verify for the custom script for file integrity and ensure that the file checksum remains the same before performing the monitor script execution. If the G2 based custom monitor script on the resource is changed, OpsRamp will redownload the original monitor script from the source for security reasons and continue the monitoring.

During this process, a critical alert about the “File checksum mismatch” will be generated on the resource, and users will be notified about the script modification on the resource.

Remote Script Executor example

Script

#!/bin/bash

CPU=$(top -bn1 | grep load | awk ‘{printf "%.2f\t\t\n", $(NF-2)}’)
MEMORY=$(free -m | awk ‘NR==2{printf "%.2f\t\t", $3*100/$2 }’)
DISK=`df -h | awk ‘$NF=="/"{ print $5}’ | sed ‘s/%//g’`

printf "{\"disk.utilization\" : %s , \"memory.utilization\" : %s , \"cpu.usage\" : %s}" "$DISK" "$MEMORY" "$CPU"

Output :

{"disk.utilization" : 23 , "memory.utilization" : 24.28 , "cpu.usage" : 0.64 }

Standard JSON output format

Format 1
{
"Metric1": 98,
"Metric2": 70,
"Metric3": 80
}

Format 2
{
"Metric1": 98,
"Metric2": "STATE",
"Metric3": 80
}
}

Format 3
{
    "MetricName1": {
        "components": {
            "component1": 70,
            "component2": 98
        }
    },
    "MetricName2": {
        "components": {
            "component1": 77,
            "component2": 98
        }
    }
}

Format 4
alertTokens: Using alertTokens, you can add more information to the alert Subject and Description.

{
    "MetricName1": {
        "components": {
            "component1": "STATE",
            "component2": 98
        },
        "alertTokens": {
            "token1": "value",
            "token2": "value2"
        }
    },
    "MetricName2": {
        "components": {
            "component1": 77,
            "component2": 98
        },
        "alertTokens": {
            "token1": "value",
            "token2": "value2"
        }
    }
}

Format 5

{
    "MetricName1": 254,
    "MetricName2": {
        "components": {
            "comp1": 90,
            "comp2": 60
        }
    },
    "MetricName3": {
        "components": {
            "component1": "STATE",
            "component2": 98
        },
        "alertTokens": {
            "token1": "value",
            "token2": "value2"
        }
    }
}

Format 6
component level alertTokens: We can specify alertToken value for each component separately as mentioned for metricName4
Note: This format supports from Agent V12 and above

{
    "MetricName1": 254,
    "MetricName2": {
        "components": {
            "comp1": 90,
            "comp2": 60
        }
    },
    "MetricName3": {
        "components": {
            "component1": "STATE",
            "component2": 98
        },
        "alertTokens": {
            "token1": "value",
            "token2": "value2"
        }
    },
     "MetricName4": {
        "components": {
            "component1": 10,
            "component2": 20
        },
        "alertTokens": {
            "token1": { 
		        "component1": "comp1 token1 value", 
		        "component2": "comp2 token1 value" 
		        },
            "token2": { 
		        "component1": "comp1 token2 value",
		        "component2": "comp2 token2 value" 
		        }
        }
    }
}

Next steps

• See Add Filter and Define Threshold
• See Setting up Agentless Monitors
• See Agent-based vs Agentless monitoring