List all monitors

Lists all configured monitors. Returns an array of monitor configurations including their IDs and current status.

GET /monitors

cURL

cURL

curl --request GET \
  --url https://api.axiom.co/v2/monitors \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://api.axiom.co/v2/monitors"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.axiom.co/v2/monitors', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.axiom.co/v2/monitors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.axiom.co/v2/monitors"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.axiom.co/v2/monitors")
  .header("Authorization", "Bearer <token>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.axiom.co/v2/monitors")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

200

[
  {
    "aplQuery": "| where severity = 'error' | count() > 100",
    "name": "Production CPU Monitor",
    "type": "Threshold",
    "id": "mon_xyz789",
    "alertOnNoData": true,
    "columnName": "cpu_usage",
    "compareDays": 7,
    "createdAt": "2024-03-20T10:00:00Z",
    "createdBy": "usr_789xyz",
    "description": "Monitors CPU usage and alerts when it exceeds 90%",
    "disabled": false,
    "disabledUntil": "2024-04-01T00:00:00Z",
    "intervalMinutes": 5,
    "notifierIds": [
      "notify_slack_prod",
      "notify_email_oncall"
    ],
    "notifyByGroup": false,
    "notifyEveryRun": false,
    "operator": "Above",
    "rangeMinutes": 5,
    "resolvable": true,
    "secondDelay": 300,
    "skipResolved": false,
    "threshold": 90,
    "tolerance": 10,
    "triggerAfterNPositiveResults": 2,
    "triggerFromNRuns": 3
  }
]

Authorizations

Authorization · string · header · required

The access token received from the authorization server in the OAuth 2.0 flow.

Response

200 - application/json

Monitor

aplQuery · string · required

APL (Axiom Processing Language) query string used for monitoring. This query defines what data to analyze and how to process it.

Example:

"| where severity = 'error' | count() > 100"

name · string · required

Name of the monitor

Example:

"Production CPU Monitor"

type · enum<string> · required

Type of monitoring check to perform:

• Threshold: Compares a numeric value against a threshold
• MatchEvent: Looks for specific events or patterns
• AnomalyDetection: Identifies unusual patterns based on historical data

Available options: Threshold, MatchEvent, AnomalyDetection

Example:

"Threshold"

id · string · required

Unique identifier for the monitor

Example:

"mon_xyz789"

alertOnNoData · boolean

Whether to alert when no data is received

Example:

true

columnName · string

Name of the column to monitor

Example:

"cpu_usage"

compareDays · number<int64>

Number of days to compare for anomaly detection

Required range: x <= 7

Example:

7

createdAt · string<date-time>

Timestamp when the monitor was created

Example:

"2024-03-20T10:00:00Z"

createdBy · string

ID of the user who created the monitor

Example:

"usr_789xyz"

description · string

Detailed description of the monitor's purpose

Example:

"Monitors CPU usage and alerts when it exceeds 90%"

disabled · boolean

Whether the monitor is currently disabled

Example:

false

disabledUntil · string<date-time> | null

Timestamp until when the monitor should remain disabled

Example:

"2024-04-01T00:00:00Z"

intervalMinutes · integer<int64>

How frequently the monitor should run, in minutes. Minimum value is 1 minute.

Required range: x >= 1

Example:

5

notifierIds · string[]

List of notifier IDs that will receive alerts. Notifiers can be email, Slack, webhook endpoints, etc.

Example:

["notify_slack_prod", "notify_email_oncall"]

notifyByGroup · boolean

Whether to group notifications

Example:

false

notifyEveryRun · boolean

Whether to send notifications on every check

Example:

false

operator · enum<string>

Comparison operator for threshold checks:

• Below: Trigger when value < threshold
• BelowOrEqual: Trigger when value <= threshold
• Above: Trigger when value > threshold
• AboveOrEqual: Trigger when value >= threshold
• AboveOrBelow: Trigger when value is outside a range

Available options: Below, BelowOrEqual, Above, AboveOrEqual, AboveOrBelow

Example:

"Above"

rangeMinutes · integer<int64>

Time window to evaluate in each check, in minutes. For example, "last 5 minutes of data"

Required range: x >= 1

Example:

5

resolvable · boolean

Whether the alert can be manually resolved

Example:

true

secondDelay · number<int64>

Delay in seconds before triggering the alert

Required range: x <= 86400

Example:

300

skipResolved · boolean

Whether to skip resolved alerts

Example:

false

threshold · number<double>

Threshold value for triggering the alert

Example:

90

tolerance · number

Tolerance percentage for anomaly detection

Required range: x <= 100

Example:

10

triggerAfterNPositiveResults · number<int64>

Number of positive results needed before triggering

Example:

2

triggerFromNRuns · number<int64>

Number of consecutive check runs that must fail before triggering an alert. Use this to avoid alerting on temporary spikes.

Example:

3