Using Remote Script Executor (RSE), you can execute scripts on both Linux and Windows workstations with different script types.

  • 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.
  • Able to use Credentials attached to the device in the script using the dynamic macro support.

Prerequisite: Gateway version 7.0.0.

Create metrics

Metrics enter the metadata to correlate the script output and must match the metrics names added to the Monitor.

  1. Select a client from the All Clients list.

  2. Go to Setup > Monitoring > Metrics.

  3. From METRICS, click + Add and enter:

    • Metric Scope: Select Partner Metric or Client Specific Metric.

    • Adaptor Type: Select Application.

    • Application Type: Select Remote Script Executor.

    • Name: Unique Name for the metric. The recommended metric naming convention is <vendorname>_<application name>_<component>_<metric> . For example, apache_tomcat_webapps_count_

    • Tag Name: User-defined tags for better filtering.

    • Display Name: Enter Display Name. For example, System Drive Free Space.

    • Description: Enter the reason for the metric.

    • Data Point type: Value chosen to plot data in the graph.

    • Units: Required values for Units. You can choose Units depending on the chosen Data Point Type.

    • Unit Multiplication Factor: Value chosen to multiply a value based on the chosen unit.

    • Data Point Conversion: One of the following options:

      • Value: To populate data using values.
      • Enumerated Map: To populate alert and graph details after adding the states such as Up or Down. The screen displays an more section where you can add the state descriptions and select Alerts and Graphs to populate data.
    • Metric Processing: One of the following values for processing the Metric:

      • Notification

      • Graph

      • Graph and Notification

      • To configure values for Graph and Notification:

        • Warning if value: Warning threshold value.
        • Critical if value: Critical threshold value.
        • Subject: Subject for the metric.
        • Description: Description for the metric.
  4. Click Save.

Remote Script Executor Create Metric

Create monitor

Custom Remote Script Executor Monitor is a collection of Remote Script Executor metrics. You can create a template using the Remote Script Executor monitor.

Prerequisite: Add the required custom parameters.

  1. From All Clients, select a client.
  2. Go to Setup > Monitoring > Monitors.
  3. From Monitors, click + Add.
  4. From CREATE A MONITOR, enter the details for the following parameters and click Save.
    • Monitor Scope: Select Partner Monitor or Client Specific Monitor.
    • Type: Select Application.
    • Application Type: Select Remote Script Executor.
    • Name: Enter a unique name for the monitor.
    • Description: Enter the reason for creating the monitor.
    • Script: Custom script in the Script text box. You can refer to Script and JSON output formats-example to view the example script.
    • Metrics: To add Metrics:
      1. From Metrics, click Add Metrics.
      2. Search the metric and click Add Metrics. The Metrics section displays the selected metric.
      3. After adding the metrics, navigate to Configuration Parameters.
    • Configuration Parameters: To add configuration Parameters:
    1. Enter Default Value for all the configuration parameters.
    2. Select the Configurable checkbox.
    3. Click +Add.
    4. Enter Configuration Parameters depending on the selected script type.
      You can view the default value for the respective Name selected.
      If you select the Custom value in Configuration Parameters, add the configuration parameter: custom.script.execution.path.
      MONITORS screen displays the new monitor.
Remote Script Executor Monitor

Macros in Remote Script Executor

Macros are implemented to address the passing of dynamic arguments to scripts. Use the following macros to make available native attributes and custom attribute defined on the resource, in the script:

Static macros

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

Dynamic macros

MacroDescription
${powershell.script.profile.flag}If the Remote Server Script Type is PowerShell then use this macro: powershell.script.profile.flag

For an example, when using PowerShell scripts on platforms with Custom PowerShell environments, choose No for the flag type to run scripts without loading user profiles. Choose Yes to execute scripts while loading user profiles.
${customattributes.serviceName}Get custom attributes of the device - If you want to use an argument in any script, apply the custom attributes on the device.

For an example, you have a custom attribute on the device with `Key: serviceName` and `Value: oracledb`. During runtime, the Value: oracledb replaces the macro: ${customattributes.serviceName} in the script.
${credentials.CredentialName.credentialField}Get the credentials added to the device - You can use (macros) credentials in the script to avoid storing the original username and password in plain text. When you run the script, the macros replace the original credentials.

For an example, if you define a credential set with a name JMXCred and added it to a device. You can use the macro ${credentials.JMXCred.username} in your script and macro will replace the original credentials in your script at runtime.
${credential.type.all}Use this macro to get all credential sets (assigned on the device) into the script.
${credential.type.name}Use this MACRO( ${credential.type.name}) to get specific credentials in the script.

For an example, If the device has SSH, WMI and Database credentials and if user want to get only database credentails inside the script then need to use ${credential.type.database} inside the script. Similarly user can get any type of credentails into the script by replacing .name with the credentails type.
Example: ${credential.type.SSH}, ${credential.type.SNMP}, ${credential.type.VMWARE} etc.
${custom.script.multi.arguments}Use this macro to create multiple custom script arguments in RSE.
[{
    "Process_Regex_Expression": "opsramp.*",
    "Process_Friendly_Name": "OpsRamp_Processes"
}, {
    "Process_Regex_Expression": "svchost.*NetworkService",
    "Process_Friendly_Name": "svchost_NetworkService"
}, {
    "Process_Regex_Expression": "trayicon.exe",
    "Process_Friendly_Name": "OpsRampTrayIcon"
}]

Credential Types

Below are the supported credential types:

Credential TypesMarcosSample Output
VMWARE${credential.type.VMWARE}
[{
"uuid":"xB35mBgN354UGM3zQFZBQSaJ",
"type":"VMWARE",
"name":"sample-vmware",
"timeoutMs":10000,
"transportType":"HTTPS",
"appName":null,
"domain":null,
"username":"testuser",
"password":"xxxxxx",
"port":443
}]
SSH${credential.type.SSH}
[{
"uuid": "NwKGzg6qqSF29Sdy5hRJrAyH",
"type": "SSH",
"name": "sample-ssh",
"timeoutMs": 10000,
"transportType": "HTTP",
"appName": null,
"userName": "testuser",
"password": "xxxxxx",
"port": 22,
"privkey": null,
"passPhrasePasswd": null,
"privKeyFileName": null,
"sshAuthType": "PASSWORD"
    }]

The following are the remaining credential types:
SNMP, XEN, WINDOWS, JMX, HTTP, Database, CIM, NETAPP, NETAPPCLUSTER, HYPERFLEX, PURESTORAGE, FTP, CISCOUCS, EMCCLARIION, EMCVNX, EMCVNXE, EMCVMAX, IBM, HPEVA, REMOTE_CLI, TELNET, XTREMIO, VIPTELA, EMCVPLEX, EMCRPA, NUTANIX, HITACHIVSP, AZURESTACK, APPLICATION, and CITRIX_CVDA.

Script execution path for configuration parameters in Linux and Windows

GatewayTarget Platform
Script TypeLinux/SSHWindows
Linux GatewayBashbash -sNot Applicable
PowershellNot ApplicableNot Applicable
Pythonpython -Not Applicable
PerlPerl - -Not Applicable
Windows GatewayBashbash -s
PowershellNot Applicablepowershell.exe
Pythonpython -python.exe
PerlPerl - -perl.exe

If your runtime is not set as an environment variable, mention the absolute path of your runtime. For example, if Python is not set as an environment variable, enter the absolute path of Python such as /usr/lib/python.

Create template

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

  1. From All Clients, select a client.

  2. Go to Setup > Monitoring >Templates.

  3. Click + Add.

  4. From MONITOR TEMPLATE, enter the details for the following parameters and click Save:

    • Select Template Scope: Template type.

    • Collector Type: Select Gateway.

    • Monitor Type: Select Monitors for G2 Templates.

    • Applicable for: Select Device.

    • Template Name: Name of the template.

    • Description: Summary of the template.

    • Generation: Generation that the template belongs to.

    • Tags: User-defined tags for better filtering.

    • Prerequisites: Essential things that you must consider while monitoring using the template. For example, check the SQL services while monitoring the SQL Parameters using the Windows templates.

    • Status: Active or End-of-life templates.

    • Notes: Information that you want to add to the template.

    • Template Family Name: Category that applies to the application. For example, Windows Server, Storage Server, and Network Server.

    • Deployment Type: One of the following methods to apply the template to the resources:

      • Custom
      • Optional
      • Standard
  5. After providing the template details, MONITOR TEMPLATE displays the Monitors section.
    The user interface for the Monitors section varies with the option selected in the Collector Type.

    • Monitor: To add details in Monitors:
    1. From the Monitors section, click Add.

    2. Enter details for the following parameters:

      • Frequency: Refer to the frequency to execute the template.
      • Monitor Definition: Monitor type.
      • When to Alert: Select Breach of a Threshold.
    3. Select Availability and Alert checkbox to initiate monitoring. The TEMPLATES section displays the configured details.

Assign template to a device

You need to create credentials to assign a template to a device.

Create credentials

If the configuration parameter remote.server.operating system is:

  • Windows, you must consider Windows type credentials.
  • LINUX or UNIX, you must consider SSH type credentials.
  1. Select a client from the All Clients list.

  2. Go to Infrastructure > Resources.

  3. From the list of devices, select a device. Navigates to the device information page.

  4. From the center pane, click Credentials.

  5. Click +Add.

  6. From Create new credential, provide details for the following parameters and click Save:

    • Name: Name of the credential.
    • Description: Description of the new credential.
    • Type: Application type. Select Windows.
    • Username: Username for the credential set.
    • Password: Password that you set for the credential set.
    • Confirm Password: Enter the same password.
    • Port: Port used to connect to the application.
    • Connection Time-out (ms): Time taken for the resource to connect to the application. The Credentials screen displays the new credentials.

Assign template

  1. From the left pane, click Infrastructure. The Infrastructure screen of the selected client is displayed.
  2. From the Resources tab, select a 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. Templates tab is displayed.
  5. From 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.

Use the following global templates to monitor your Linux resources:

  • Gateway - Linux OS Performance Remote Monitoring
  • Gateway - Linux OS Performance Remote Monitoring - V2
  • Gateway - Linux Network Remote Monitoring

View graphs

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

  1. From the left pane, click Infrastructure. The Infrastructure screen of the selected client is displayed.
  2. From the Resources tab, select a 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.
Graphical Representation

Troubleshooting

  • The device is accessible to the gateway.
  • The appropriate port is available from the remote server.

Remote script executor example

#!/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 formats: Remote script executor script

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

{
    "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" 
        }
        }
    }
}

Multiple Custom Script Arguments in Macro

For any RSE script, we can pass upto 5 different types of custom arguments and for each argument we can pass a maximum of 20 values.

Each Custom argument contains 3 fields:

  • Name
  • Description
  • Default Value

Here, Name and Description are the mandatory fields for a custom script argument.
The Default value is an optional field, which we can specify only if we want to give any default value to the custom script argument.

Marco Name: ${custom.script.multi.arguments}

Prerequisites

  • Multiple custom script arguments are supported with Agent and Gateway version 14.0 and above.
  • Macro custom.script.multi.arguments will support Agent and Gateway collector types.

Windows Process Monitoring - Use Case

This is a real time use case for multiple custom scrpit aurgument usages.

Step 1- Create Metric: Refer to the Document to know how to create metric.

Reporting apps
Here, user need to create two metrics such as: system.windows.process.handlecount and system.windows.process.threadcount

Step 2- Create a Monitor: Refer to the Document to know how to create a monitor.
While creating a monitor, make the following changes:

  • Under the Script section, use the below sample script.
$customArgs = ${custom.script.multi.arguments}
 
If (($([Int]$customArgs.Length) -eq 0) -or ($([String]$customArgs) -eq "Custom Script Arguments") -or ($($([String]$customArgs).Trim()) -eq ""))
{
    write-host "If a user does not provide any custom arguments, This script will exit automatically..."
    Exit 
}
 
$argSets = $([String]$customArgs) | convertFrom-Json
$rawDataColItems = Get-WMIObject Win32_PerfRawData_PerfProc_Process -namespace root\cimv2 -ErrorAction Stop | select Name, HandleCount, ThreadCount, IDProcess
    $processDataColItems = Get-WMIObject Win32_Process -namespace root\cimv2 -ErrorAction Stop | select Name, CommandLine, ProcessId
    $win32ProcessNameArgsDict = @{}
    $win32ProcessNamesDict = @{}
    ForEach($processDataColItem in $processDataColItems)
    {
        $win32ProcessNameArgsDict.$([String]$processDataColItem.ProcessId) = $([String]$processDataColItem.CommandLine)
        $win32ProcessNamesDict.$([String]$processDataColItem.ProcessId) = $([String]$processDataColItem.Name).replace(".exe","")
    }
 
    $handleCountStr = $ThreadCountStr  = ""
     
    ForEach($argSet in $argSets)
    {
        $reqProcessesCount = 0
        [UInt32]$handleCount = 0
        [UInt32]$ThreadCount = 0
        $componentName = ""
        $searchString = ([String]$argSet.Process_Regex_Expression).Trim()
        $componentName = ([String]$argSet.Process_Friendly_Name).Trim()
        if($searchString -eq "")
        {
            continue
        }
         
        ForEach($rawDataColItem in $rawDataColItems)
        {
            $procId = $([String]$rawDataColItem.IDProcess)
            $input = $([String]$win32ProcessNameArgsDict.$procId)
             
            If($input -eq "")
            {
                $input = $([String]$win32ProcessNamesDict.$procId)
                $searchString = $($searchString.Tolower()).replace(".exe","")
            }
            If($input -match $searchString)
            {
                If ($([String]$componentName) -eq "")
                {
                    $componentName = $($([String]$win32ProcessNamesDict.$procId).Trim())
                }
                $handleCount = $handleCount + $([UInt32]$rawDataColItem.HandleCount)
                $ThreadCount = $ThreadCount + $([UInt32]$rawDataColItem.ThreadCount)    
            }
        }
        If ($([String]$componentName) -eq "")
        {
            $componentName = $searchString
        }
        $handleCountStr += """$componentName""" + ":" + "$handleCount" + ","
        $ThreadCountStr += """$componentName""" + ":" + "$ThreadCount" + ","
    }
    $handleCountStr = $handleCountStr.Substring(0, $handleCountStr.Length - 1)
    $ThreadCountStr = $ThreadCountStr.Substring(0, $ThreadCountStr.Length - 1)
 
    Write-Host  "{""system.windows.process.handlecount"":{ ""components"": { $handleCountStr }}, ""system.windows.process.threadcount"":{ ""components"": { $ThreadCountStr }}}"

   
  • Under the Metric section, click +Add and use the metrics created in Step 1.
  • Under the Configuration Parameters section, click + Add and select custom.script.multi.arguments as shown below.
    Reporting apps

Step 3- Pass multiple custom script arguments: In the Monitor Creation Page, we must pass the following multiple custom script arguments.

  • Argument 1:
    • Name: Process_Regex_Expression
    • Description: Provide regex expression to match process name and arguments.(Ex: opsramp.*)
  • Argument 2:
    • Name: Process_Friendly_Name
    • Description: Provide process friendly name to be used as metric component name.(Ex: Opsramp_Processes).
Reporting apps

Finally, click Save to save the Monitor page.

Step 4- Create a Template: Refer the Document to know how to create a template.
Create the template with above created metrics and monitor.

Reporting apps

Step 5- Assign a template: Refer the Document to know how to assign template.

Reporting apps

Below is the final script output

{
    "system.windows.process.handlecount": {
        "components": {
            "OpsRamp_Processes": 0,
            "svchost_NetworkService": 539,
            "OpsRampTrayIcon": 0
        }
    },
    "system.windows.process.threadcount": {
        "components": {
            "OpsRamp_Processes": 0,
            "svchost_NetworkService": 19,
            "OpsRampTrayIcon": 0
        }
    }
}

Generate Alert Tokens in RSE

The Alert Tokens feature is applicable for RSE G2 based templates that utilize the Agent or Gateway collector types. This feature will be useful when you wish to include additional details about an alert in the alert Subject or Description.

To incorporate this feature, you need to include the alert tokens information within your script. The information should be in valid JSON format and should be specified as a string called “alertTokens” in the script. Here is an example:

"{`"windows_certStore_certificates_expiry_inDays_v2`":{`"components`":$cert_details ,`"alertTokens`":{`"cert.info`":""$cert_info""}}}"

Windows Certificates Store Monitoring - Use Case

This is a real time use case to generate alert tokens in RSE.

Step 1- Create a Metric: Refer to the Document to know how to create a metric.

While creating a metric, make the following changes:

  • Name: In this case, we named the metric as windows_certStore_certificates_expiry_inDays_v2.
  • Metric Processing: Choose Graph and Notification.
  • Description: In the description section, add a string as cert.info:$cert.info to display more information on the alert.
Reporting apps

Now, we have created a metric successfully.

Step 2- Create a Monitor: Refer to the Document to know how to create a monitor.

While creating a monitor, make the following changes:

  • Under the Metric section, click +Add and use the metrics created in Step 1.
  • Under Script section, use the below sample RSE script.
    $custom_args = ${custom.script.arguments}
    $global:certs = @{}
    $global:cert_attributes = @{}
    #####################################################
    Function get_attributes
    {
    param($input_certs)
             
            $now = Get-Date
     
            Foreach ($value in $input_certs)
            {
               $CertIssuer = $value.Issuer
               #$CertIssuer
               $CertIssuer = $CertIssuer.split(",")
               $cert_name = $CertIssuer[0]
               $cert_name = $cert_name -replace "CN=|OU=",""
               $CertSubject = $value.Subject
               #$CertSubject
               $CertSubject = $CertSubject.split(",")
               $cert_subject = $CertSubject[0]
               $cert_subject = $cert_subject -replace "CN=|OU=",""
               $cert_Serialnumber = $value.Serialnumber
               $count = (New-TimeSpan -Start $now -End $value.NotAfter).Days
               $certs[$cert_name] = [int]$count
               $attributes = "Issuer - $cert_name; Subject - $cert_subject; Serial Number - $cert_Serialnumber"
               #$attributes
               $cert_attributes[$cert_name] = $attributes
            }
    }
    #####################################################
    if((([String]$custom_args).Trim()) -eq "" -or ([int](($custom_args).length)) -eq 0)
    {
        write-host "Empty custom script arguments, hence exiting the script"
        Exit
    }
    else{
        Try
        {
            if((([String]$custom_args).Trim()) -eq "all")
            {
                $CertsAll = Get-ChildItem -path cert: -Recurse -ErrorAction Stop| where-object {$_.NotAfter -gt (Get-Date)} 
                get_attributes $CertsAll
            }
            else
            {
                $StrDecodedArgs = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($custom_args))
                #Write-Host $StrDecodedArgs
                $arrParams = $StrDecodedArgs -Split(';')
                $StrCertPaths = $arrParams[0]
                $StrExclusionList = $arrParams[1]
     
                $arrCertPaths = $StrCertPaths -Split(',')
                $ExclusionItems = $StrExclusionList -Split(',')
     
                 
                If ($([int]$arrCertPaths.count)    -ge 1)
                {
                  Foreach ($Param In $arrCertPaths)
                  {
                    $CertificateStore = $Param.Trim()
                    If (Test-Path $CertificateStore) 
                    {
                        #write-host $CertificateStore
                        $CertsAll = Get-ChildItem -path $CertificateStore -ErrorAction Stop | where-object {$_.NotAfter -gt (Get-Date)} | where-object{$_.Thumbprint -notin $ExclusionItems}
                        #Loop through the params (cert store) to verify the certificates expiring in each store
                        If ($([int]$CertsAll.count) -ge 1)  
                        {
                            get_attributes $CertsAll
                        }
                    }
                  }
                }
                else
                {
                    $finalJsonOutput = "{`"windows_certStore_certificates_expiry_inDays_v2`":{`"components`":{} }}"
                    write-host $finalJsonOutput
                    Exit
                }
            }
            $cert_details = $certs | ConvertTo-Json -compress 
            #-------------------------------------------------------------------------------
            $cert_info = ""
            foreach ($certName in $cert_attributes.Keys) { 
            $cert_info += $certName + ":"+ $($cert_attributes[$certName]) + ","
            } 
            $cert_info = $cert_info.Substring(0, $cert_info.Length - 1)
             
            $finalJsonOutput = "{`"windows_certStore_certificates_expiry_inDays_v2`":{`"components`":$cert_details ,`"alertTokens`":{`"cert.info`":""$cert_info""}}}"
            write-host $finalJsonOutput
        }
     
    Catch
    {
        write-host "Exception - Windows_Certificates_Store_Expiry_InDays_v2: " $_.Exception.Message
        Exit
    }
    }

Now, we have created a monitor successfully.

Step 3- Create a Template: Refer the Document to know how to create a template.

Create the template using above created metric and monitor.

Reporting apps

Step 5- Assign a template: Refer the Document to know how to assign a template.

Assign the template to a device and provide any custom script arguments, if applicable. You can refer to the screenshot below for reference.

Reporting apps

Below is the final script output

{
  "windows_certStore_certificates_expiry_inDays_v2": {
    "components": {
      "Baltimore CyberTrust Root": 716,
      "ISRG Root X1": 4391,
      "Microsoft Root Certificate Authority 2010": 4410,
      "VeriSign Class 3 Public Primary Certification Authority - G5": 4799,
      "GlobalSign Root CA": 1707,

      "CLIUSR":30
    },
    "alertTokens": {
      "cert.info": "Baltimore CyberTrust Root:Issuer - Baltimore CyberTrust Root; Subject - Baltimore CyberTrust Root; Serial Number - 020000B9,ISRG Root X1:Issuer - ISRG Root X1; Subject - ISRG Root X1; Serial Number - 008210CFB0D240E3594463E0BB63828B00,Microsoft Root Certificate Authority 2010:Issuer - Microsoft Root Certificate Authority 2010; Subject - Microsoft Root Certificate Authority 2010; Serial Number - 28CC3A25BFBA44AC449A9B586B4339AA,VeriSign Class 3 Public Primary Certification Authority - G5:Issuer - VeriSign Class 3 Public Primary Certification Authority - G5; Subject - VeriSign Class 3 Public Primary Certification Authority - G5; Serial Number - 18DAD19E267DE8BB4A2158CDCC6B3B4A,GlobalSign Root CA:Issuer - GlobalSign Root CA; Subject - GlobalSign Root CA; Serial Number - 040000000001154B5AC394,CLIUSR: Issuer - CLIUSR; Subject - CLIUSR; Serial Number - 67983B6CBC96A6AE424D50017BF6ECE3"
    }
  }
}

View the Alert Tokens

To view the Alert Tokens, follow these steps:

  1. Navigate to the Infrastructure > Resources section in the user interface.
  2. Select the desired resource for which you want to view the details.
  3. Navigate to the Details tab.
  4. You should be able to see the alert token information as shown in the figure.
Reporting apps