Documentation

What are Monitors?

Monitors are the core component of UptimeEye that allow you to check the health and performance of your websites, APIs, and services. Each monitor consists of one or more steps that define what to check and how to validate the results.

Monitor Types

UptimeEye supports the following monitor types:

• HTTP - Monitor HTTP/HTTPS endpoints with customizable requests and response validation
• DNS - Check DNS records and validate their values
• ICMP - Ping servers to check their availability and response time

Creating a Monitor

To create a new monitor:

1. Navigate to the Monitors page in your project
2. Click the "New Monitor" button
3. Enter a name for your monitor
4. Select a notification channel to receive alerts
5. Configure the monitor options (check interval, timeout, etc.)
6. Add one or more monitor steps (see Monitor Steps section)
7. Click "Create Monitor" to save your configuration

Monitor Options

When creating or editing a monitor, you can configure the following options:

• Check Interval - How often the monitor should run (30s, 1m, 2m, 3m, 5m, 10m, 30m, 6h, 12h, or 24h). Minimum interval depends on your plan.
• Timeout - How long to wait for a response before considering the check failed (5-60 seconds)
• Follow Redirects - Whether to follow HTTP redirects automatically
• Failure Threshold - Number of consecutive failures before a monitor is marked as down (1-10, default 1)
• Location Threshold - Number of locations that must report failure before triggering an alert (1-10, default 1)
• Locations - Select which geographic regions to run checks from: EU Central (Frankfurt), US East (N. Virginia), US West (Oregon), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo)

Each monitor can have up to 5 steps. You can also import existing requests by pasting a cURL command when configuring an HTTP step.

What are Monitor Steps?

Monitor steps define the individual checks that a monitor performs. Each step can have its own configuration, assertions, and variable extractions. Steps are executed in sequence, and variables extracted in one step can be used in subsequent steps.

Step Configuration

When creating a monitor step, you'll go through a 4-step wizard:

1. Basics - Define the step name and type (HTTP, DNS, ICMP)
2. Details - Configure the request details (URL, method, headers, body)
3. Assertions - Add assertions to validate the response
4. Variables - Extract variables from the response for use in subsequent steps

Assertions

Assertions allow you to validate the response from your monitored endpoint. Different assertion types are available depending on the monitor type:

HTTP Assertions

• Status Code - Check if the status code is or is not a specific value
• Response Time - Check if the response time is less than a specific value
• Body - Check if the response body contains, does not contain, is, or is not a specific value
• Body JSON Path - Check if a specific JSON path in the response body meets certain criteria
• Header - Check if a specific header contains, does not contain, is, or is not a specific value
• SSL Certificate - Validate SSL certificate properties:
  • Issuer - Certificate issuer name
  • Subject - Certificate subject name
  • Expires In - Days until certificate expiration (e.g., alert if less than 30 days)
  • DNS Names - Subject Alternative Names (SANs) on the certificate

DNS Assertions

• DNS Record - Check if a specific DNS record (A, AAAA, MX, etc.) contains, does not contain, is, or is not a specific value

ICMP Assertions

• Response Time - Check if the ping response time is less than a specific value

Global Variables

UptimeEye supports global variables to help you dynamically generate values inside your requests. These can be used in URLs, headers, bodies, or assertions.

Syntax follows the pattern: {{ variable(args) }}

Available global variables:

These dynamic variables are especially useful for load testing, simulating unique users or sessions, and avoiding caching effects.

Example usage in a request body:

{  "email": "user+{{ numeric 5 }}@example.com",  "password": "{{ alphanumeric 12 }}"}

What are Scheduled Tasks?

Scheduled Tasks (also known as cron job monitoring or heartbeat monitoring) let you monitor background jobs, cron jobs, and any recurring processes. UptimeEye uses a dead man's switch approach: your task sends a ping (beat) to UptimeEye at regular intervals. If a beat is missed, UptimeEye alerts you.

Task Types

UptimeEye supports two types of scheduled tasks:

• Simple Task - Define a fixed interval (e.g., every 5 minutes, every 2 hours, every 1 day). Best for tasks that run at regular intervals.
• Cron Task - Use a cron expression (e.g., 0 9 * * 1-5) with timezone support. Best for tasks with complex schedules.

Creating a Scheduled Task

To create a new scheduled task:

1. Navigate to the Scheduled Tasks page in your project
2. Click the "New Scheduled Task" button
3. Enter a name for your task
4. Select a notification channel to receive alerts
5. Choose the task type (Simple or Cron)
6. Configure the schedule (interval or cron expression with timezone)
7. Optionally set a grace period (minutes to wait before marking as down)
8. Click "Create Scheduled Task" to save your configuration

Beat API (Integration Endpoints)

After creating a scheduled task, you'll receive a unique task ID. Use this ID to send beats from your application using simple HTTP requests. All endpoints accept GET, POST, and HEAD methods.

Example usage with cURL:

# Send a beat after your cron job completes
curl -X GET https://api.uptimeeye.com/v1/beat/YOUR_TASK_ID

# Report failure if something goes wrong
curl -X POST https://api.uptimeeye.com/v1/beat/YOUR_TASK_ID/fail

Grace Period

The grace period defines how many minutes UptimeEye waits after a missed beat before marking the task as down and sending an alert. This is useful for tasks that may occasionally take longer than expected. Set it to 0 for immediate alerting.

What are Incidents?

Incidents allow you to track and communicate service disruptions to your team and customers. You can create incidents manually, link them to affected monitors, scheduled tasks, and status pages, and provide updates as the situation progresses.

Incident Statuses

Each incident progresses through a 4-stage lifecycle:

1. Investigating - The issue has been detected and is being investigated
2. Identified - The root cause has been identified
3. Monitoring - A fix has been applied and the situation is being monitored
4. Resolved - The incident has been fully resolved

Creating an Incident

To create a new incident:

1. Navigate to the Incidents page in your project
2. Click the "New Incident" button
3. Enter a title and initial status message
4. Set the occurrence time (defaults to now, can be set to a past time)
5. Select affected monitors and scheduled tasks
6. Link relevant status pages so the incident is visible to your users
7. Click "Create Incident" to publish it

Incident Updates

As you work through an incident, you can post updates to keep stakeholders informed. Each update includes a status change and a message describing the current state. Updates are displayed chronologically on linked status pages, providing a full timeline of the incident.

What are Notification Channels?

Notification Channels define how and where UptimeEye sends alerts when monitors or scheduled tasks detect issues. You can create multiple notification channels and assign them to different monitors or tasks.

Available Integrations

UptimeEye supports the following notification integrations:

• Email - Send notifications to one or more email addresses
• Slack - Send notifications to a Slack channel
• Microsoft Teams - Send notifications to a Microsoft Teams channel
• Discord - Send notifications to a Discord channel
• Telegram - Send notifications to a Telegram chat
• PagerDuty - Trigger incidents through PagerDuty's Events API
• Webhook - Send notifications to a custom HTTP endpoint

Configuring PagerDuty

PagerDuty integrates via the Events API. To configure it:

1. Create or locate an Events API v2 integration on the relevant PagerDuty service.
2. Copy the generated routing key and paste it into the PagerDuty form in UptimeEye.
3. Optionally provide an Event Source label (e.g. production-api) to help identify where incidents originate.
4. Enable the integration and send a test alert to verify incident creation in PagerDuty.

Creating a Notification Channel

To create a new notification channel:

1. Navigate to the Notification Channels page in your project
2. Click the "New Notification Channel" button
3. Enter a name for your channel
4. Click "Create Notification Channel" to save the basic configuration
5. On the channel settings page, add one or more integrations
6. Configure each integration with the required settings (e.g., email addresses, webhook URLs)

Notification Events

UptimeEye sends notifications for various events, including:

• Monitor status changes (up to down, down to up)
• Scheduled task missed executions

What are Status Pages?

Status Pages allow you to share the status of your services with your users or team members. You can create public status pages for your customers or private status pages for internal use.

Status Page Features

• Organize monitors and scheduled tasks into sections
• Display uptime, response time, and incident history
• Customize which statistics to show for each monitor or task
• Public or private visibility options
• Custom URL slug for easy access

Creating a Status Page

To create a new status page:

1. Navigate to the Status Pages page in your project
2. Click the "New Status Page" button
3. Enter a name and URL slug for your status page
4. Choose whether the page should be public or private
5. Add one or more sections to organize your monitors and tasks
6. For each section, add the relevant monitors and scheduled tasks
7. Configure which statistics to display for each item
8. Click "Create Status Page" to save your configuration

Accessing Status Pages

Once created, your status page will be available at a URL based on the slug you provided. For public status pages, anyone with the URL can access it. For private status pages, authentication is required.

What are Secure Variables?

Secure Variables allow you to store sensitive information, such as API keys, passwords, or tokens, securely in UptimeEye. These variables can then be used in your monitors without exposing the actual values in the UI or logs.

Creating Secure Variables

To create a new secure variable:

1. Navigate to the Variables page in your project
2. Click the "New Variable" button
3. Enter a key (name) for your variable
4. Enter the value you want to store
5. Check the "Secure" checkbox to mark the variable as secure
6. Click "Create Variable" to save your configuration

Note: Once a secure variable is created, its value cannot be viewed again, even by administrators. You can update the value if needed, but you cannot retrieve the original value.

Using Secure Variables in Monitors

To use a secure variable in a monitor step, use the syntax {{variableName}} in the URL, headers, or body of the step. UptimeEye will automatically replace this placeholder with the actual value when executing the monitor.

This allows you to use sensitive information in your monitors without exposing it in the UI or logs. For example, you can use secure variables for:

• API keys in request headers
• Passwords in authentication requests
• Tokens in request parameters
• Sensitive data in request bodies