Additional JavaScript objects

Overview

This section describes Zabbix additions to the JavaScript language implemented with Duktape and supported global JavaScript functions.

Built-in objects

Zabbix

The Zabbix object provides interaction with the internal Zabbix functionality.

Example:

Zabbix.log(3, "this is a log entry written with 'Warning' log level")

You may use the following aliases:

The total size of all logged messages is limited to 8 MB per script execution.

Example (delay execution by 15 seconds):

Zabbix.sleep(15000)

HttpRequest

This object encapsulates cURL handle allowing to make simple HTTP requests. Errors are thrown as exceptions.

The initialization of multiple HttpRequest objects is limited to 10 per script execution.

Example:

try {
           Zabbix.log(4, 'jira webhook script value='+value);
           var result = {
               'tags': {
                   'endpoint': 'jira'
               }
           },
           params = JSON.parse(value),
           req = new HttpRequest(),
           fields = {},
           resp;
           req.addHeader('Content-Type: application/json');
           req.addHeader('Authorization: Basic '+params.authentication);
           fields.summary = params.summary;
           fields.description = params.description;
           fields.project = {"key": params.project_key};
           fields.issuetype = {"id": params.issue_id};
           resp = req.post('https://tsupport.zabbix.lan/rest/api/2/issue/',
               JSON.stringify({"fields": fields})
           );
           if (req.getStatus() != 201) {
               throw 'Response code: '+req.getStatus();
           }
           resp = JSON.parse(resp);
           result.tags.issue_id = resp.id;
           result.tags.issue_key = resp.key;
       } catch (error) {
           Zabbix.log(4, 'jira issue creation failed json : '+JSON.stringify({"fields": fields}));
           Zabbix.log(4, 'jira issue creation failed : '+error);
           result = {};
       }
       return JSON.stringify(result);

XML

The XML object allows the processing of XML data in the item and low-level discovery preprocessing and webhooks.

In order to use XML object, server/proxy must be compiled with libxml2 support.

Example:

Input:

<menu>
           <food type = "breakfast">
               <name>Chocolate</name>
               <price>$5.95</price>
               <description></description>
               <calories>650</calories>
           </food>
       </menu>

Output:

{
           "menu": {
               "food": {
                   "@type": "breakfast",
                   "name": "Chocolate",
                   "price": "$5.95",
                   "description": null,
                   "calories": "650"
               }
           }
       }

Serialization rules

XML to JSON conversion will be processed according to the following rules (for JSON to XML conversions reversed rules are applied):

1. XML attributes will be converted to keys that have their names prepended with ‘@’.

Example:

Input:

 <xml foo="FOO">
          <bar>
            <baz>BAZ</baz>
          </bar>
        </xml>

Output:

 {
          "xml": {
            "@foo": "FOO",
            "bar": {
              "baz": "BAZ"
            }
          }
        }

2. Self-closing elements (<foo/>) will be converted as having ‘null’ value.

Example:

Input:

<xml>
         <foo/>
       </xml>

Output:

{
         "xml": {
           "foo": null
         }
       }

3. Empty attributes (with “” value) will be converted as having empty string (‘’) value.

Example:

Input:

<xml>
         <foo bar="" />
       </xml>

Output:

{
         "xml": {
           "foo": {
             "@bar": ""
           }
         }
       }

4. Multiple child nodes with the same element name will be converted to a single key that has an array of values as its value.

Example:

Input:

<xml>
         <foo>BAR</foo>
         <foo>BAZ</foo>
         <foo>QUX</foo>
       </xml>

Output:

{
         "xml": {
           "foo": ["BAR", "BAZ", "QUX"]
         }
       }

5. If a text element has no attributes and no children, it will be converted as a string.

Example:

Input:

<xml>
           <foo>BAZ</foo>
       </xml>

Output:

{
         "xml": {
           "foo": "BAZ"
          }
       }

6. If a text element has no children, but has attributes: text content will be converted to an element with the key ‘#text’ and content as a value; attributes will be converted as described in the serialization rule 1.

Example:

Input:

<xml>
         <foo bar="BAR">
           BAZ
         </foo>
       </xml>

Output:

{
         "xml": {
           "foo": {
             "@bar": "BAR",
             "#text": "BAZ"
           }
         }
       }

Global JavaScript functions

Additional global JavaScript functions have been implemented with Duktape:

• btoa(data) - encodes the data to base64 string
• atob(base64_string) - decodes base64 string

try {
           b64 = btoa("utf8 string");
           utf8 = atob(b64);
       } 
       catch (error) {
           return {'error.name' : error.name, 'error.message' : error.message}
       }

• md5(data) - calculates the MD5 hash of the data

• sha256(data) - calculates the SHA256 hash of the data

• hmac(‘<hash type>’,key,data) - returns HMAC hash as hex formatted string; MD5 and SHA256 hash types are supported; key and data parameters support binary data. Examples:

  • hmac('md5',key,data)
  • hmac('sha256',key,data)

• sign(hash,key,data) - returns calculated signature (RSA signature with SHA-256) as a string, where:
  hash - only ‘sha256’ is allowed, otherwise an error is thrown;
  key - the private key. It should correspond to PKCS#1 or PKCS#8 standard. The key can be provided in different forms:

  • with spaces instead of newlines;
  • with escaped or non-escaped ‘’s instead of newlines;
  • without any newlines as a single-line string;
  • as a JSON-formatted string.

  The key also can be loaded from a user macro/secret macro/vault.

  data - the data that will be signed. It can be a string (binary data also supported) or buffer (Uint8Array/ArrayBuffer).
  OpenSSL or GnuTLS is used to calculate the signatures. If Zabbix was built without any of these encryption libraries, an error will be thrown (‘missing OpenSSL or GnuTLS library’).
  This function is supported since Zabbix 6.4.1.