Complex Datapoints

Complex datapoints enable you to create new, calculated values derived from existing normal or complex datapoints. Unlike normal datapoints, which capture raw data directly from monitored systems, complex datapoints perform calculations using those collected values to generate metrics that can be used more effectively in dashboards, reports, and alerts.

LogicMonitor supports the following methods for calculating complex datapoints:

• Standard complex datapoints—Use expression syntax to calculate new values from datapoints, resource properties, or numbers.
  For example, the SNMP interface MIB provides an OID that reports the inbound octets on an interface (InOctets). This can be converted to the value carried by the InOctet datapoint to Mbps using the following expression: InOctets*8/1000/1000
• Groovy complex datapoints—Use Groovy scripts to perform advanced processing on raw data when expressions are not sufficient.
  In a Groovy complex datapoint, you have access to the raw data payload, but not the actual datapoints (for example, those calculated as a “counter” or “derive”). In addition, you can use Groovy for calculations based on both resource and instance properties. Typically, you can use a Groovy complex datapoint for manipulating data in a way that cannot be achieved with a standard complex datapoint.

Together, these options provide flexibility—enabling everything from basic conversions to complex custom logic—so you can tailor monitoring to reflect the metrics most important to your environment.

Expression Syntax for Standard Complex Datapoint

When constructing standard complex datapoints in LogicMonitor, you use datapoint expression syntax to define how new values are calculated from existing datapoints, resource properties, or numerical constants. These expressions can perform arithmetic, logical, and conditional operations, and can include mathematical functions or constants.

Expression Operands

You can use the following kinds of operands: 

• Datapoint names
• Resource property names
• Arbitrary numbers

The following example uses numbers and datapoint names to calculate the percentage of inbound packets discarded on a particular interface:
100 * InDiscards / (InBroadcastPkts + InUcastPkts + InMulticastPkts + InDiscards) * ##BandwidthLimit##

Expression Operators

Datapoint expressions support a variety of operators for performing calculations and evaluations. These include arithmetic, bitwise, and logical operators, enabling you to build formulas that manipulate and compare datapoint values.

The following table summarizes the available operator types and their functions:

Expression Functions

Datapoint expressions support a range of built-in functions that extend their calculation and evaluation capabilities beyond basic operators. These include conditional, comparison, and mathematical functions, as well as constants for use in formulas.

The following table outlines the available function types and their purposes:

Special Cases for Standard Complex Datapoints

In some cases, datapoint expressions require special handling for negative or unknown (NaN) values to ensure accurate calculations and display results.

The following table summarizes these special cases and how LogicMonitor processes them:

Expression Syntax for Groovy Complex Datapoints

When you need to do additional processing not possible with datapoint expressions, you can turn to Groovy scripting for more full-featured datapoint calculations. Groovy complex datapoints use a Groovy script to process the raw collected data. In a Groovy complex datapoint, you have access to the raw data payload, but not the actual datapoints (for example, those calculated as a “counter” or “derive”). In addition, you can use Groovy for calculations based on both resource and instance properties.

Groovy complex datapoints are typically used when data manipulation cannot be achieved with a standard complex datapoint. They are also useful when the module does not already use an embedded Groovy script for data collection, or when it does but is an official LogicMonitor module. In these cases, a Groovy complex datapoint provides a flexible way to perform advanced data processing and customization.

When you use Groovy to construct a complex datapoint, the Collector pre-populates Groovy variables with the raw data collected from normal datapoints. The type and syntax of these objects varies based on the collection method used by the DataSource.

The following table lists the variable names available for each collection method and demonstrates how Groovy complex datapoints can use them to process and manipulate raw monitoring data. Each example highlights a common use case and the type of Groovy logic applied to return meaningful, calculated values:

// iterate through output array
output.each
{ line ->
    (oid, value) = line.toString().split('=');
    // get inOctet and outOctet values
    if (oid.startsWith(".1.3.6.1.2.1.31.1.1.1.6"))
    {
        totalInOctets = value.toFloat();
    }
    else if (oid.startsWith(".1.3.6.1.2.1.31.1.1.1.10"))
    {
        totalOutOctets = value.toFloat();
    }
}
// sum the values and return
totalOctets = totalInOctets + totalOutOctets;
return(totalOctets);

if (status < 2)
{
    myStatus = 5;
}
else
{
    myStatus = 10;
}
return(myStatus);

rawDate=output["LOCALDATETIME"];
return(rawDate);

rawDate = output["solr/##WILDVALUE2##:type=/replication,id=org.apache.solr.handler.ReplicationHandler:replicationFailedAt"]
fd = Date.parse('EEE MMM dd HH:mm:ss z yyyy', rawDate)
today = new Date()
return((today.time - fd.time)/1000)

Resource and Instance Properties in Groovy Complex Datapoints

You can use the resource or instance properties that you collect within a Groovy complex datapoint.

The following tables explains how the resource or instance properties can be referenced within Groovy:

For more information and examples, see Embedded Groovy Scripting.

Configuring a Complex Datapoint

1. In LogicMonitor, navigate to Modules.
2. Select My Module Toolbox, and then either create a new DataSource or navigate to the DataSource you want to create a complex datapoint for.
   For more information, see DataSources Configuration or Modules Management.
3. Configure or modify the settings as needed for the module.
   For more information, see DataSources Configuration.
4. In the Datapoints settings, select Add a Complex Datapoint, and do the following:
5. In the Name field, enter a name for the datapoint.
6. In the Description field, enter a description as needed.
7. From the Method dropdown, select one of the following methods you want to use to calculate the datapoint:
   • To calculate a standard complex datapoint, select “Use an expression (infix or rpn) to calculate the value”, and then enter the expression for calculation in the Expression field.
     For more information on the expressions you can use to calculate a standard complex datapoint, see Expression Syntax for Standard Complex Datapoints.
   • To calculate a groovy complex datapoint, select “Use a groovy script to calculate the value”, and then enter the groovy script in the Groovy source code field.
     For more information on groovy scripts syntax you can use to calculate a standard complex datapoint, see Expression Syntax for Groovy Complex Datapoints.
8. (Optional) To display readable status values for a datapoint, select Add Status Display Name, and then do the following:
   1. In the Status Value field, enter the number value returned by the datapoint. 
   2. From the Operator dropdown menu, select how you want the value to apply:
      • When the value is higher than the specified value, select “(>) Greater than.”
      • When the value reached or exceeds the specified value, select “(>=) Greater than or equal to.”
      • When the value is lower than the specified value, select “(<) Less than.”
      • When the value is at or below the specified value, select “(<=) Less than or equal to.”
      • When the value exactly matches the specified value, select “(=) Equal to.”
      • To all values except the specified value, select “(!=) Not equal to.”
   3. In the Display Name field, enter the corresponding status text (for example, 3 = Non-operational).
   4. Select Apply to save. 
   5. Configure the Alert Thresholds settings as necessary.
      For more information, see Alert Threshold Overview.
   6. Select  to save the datapoint.
9. Configure any additional settings for the DataSource, and then select Save.