ConnectWise Automate Monitors · git:20260713.1fbd3f3 · 2026-07-13 · sha256 f46bd893631d418e
ConnectWise Automate Monitors git:20260713.1fbd3f3A
Immutable. This exact content is served forever at /api/v1/blob/f46bd893631d418e.
---
name: "ConnectWise Automate Monitors"
description: >
Use this skill when working with ConnectWise Automate monitors - configuring
thresholds, creating templates, and assigning to computers. Covers monitor types
(internal, remote, SNMP), alert thresholds, monitor templates, assignment methods,
and monitor status evaluation.
when_to_use: >-
When configuring thresholds, creating templates, and assigning to computers. Use when: automate
monitor, automate monitoring, automate threshold, monitor template, monitor assignment, monitor
alert, internal monitor, remote monitor, snmp monitor, or labtech monitor.
---
# ConnectWise Automate Monitor Management
## Overview
Monitors in ConnectWise Automate continuously evaluate conditions on managed endpoints and generate alerts when thresholds are exceeded. This skill covers monitor types, threshold configuration, template management, and assignment strategies.
## Key Concepts
### Monitor Types
| Type | Description | Execution |
|------|-------------|-----------|
| **Internal Monitor** | Runs on the Automate server | Checks agent data |
| **Remote Monitor** | Runs from the Automate server | Network checks (ping, port, HTTP) |
| **Agent Monitor** | Runs on the endpoint agent | Local system checks |
| **SNMP Monitor** | Polls SNMP-enabled devices | Network device monitoring |
| **Script Monitor** | Executes script for check | Custom logic |
### Monitor Categories
| Category | Examples |
|----------|----------|
| **Performance** | CPU, memory, disk usage |
| **Service** | Service status, process running |
| **Event Log** | Windows Event Log entries |
| **Network** | Ping, port open, HTTP response |
| **Security** | AV status, patch compliance |
| **Hardware** | Drive health, temperature |
| **Application** | Specific app monitoring |
### Alert Severity Levels
| Level | Value | Description |
|-------|-------|-------------|
| `Information` | 1 | Informational, no action needed |
| `Warning` | 2 | Potential issue, investigate |
| `Error` | 3 | Failure, action required |
| `Critical` | 4 | Severe issue, immediate action |
## Field Reference
### Monitor Definition Fields
```typescript
interface Monitor {
// Identifiers
MonitorID: number; // Primary key
MonitorGUID: string; // Global unique ID
Name: string; // Monitor name
// Type and Category
MonitorType: MonitorType; // Internal, Remote, Agent, SNMP
Category: string; // Performance, Service, etc.
Enabled: boolean; // Is active
// Check Configuration
CheckInterval: number; // Seconds between checks
FailAfter: number; // Failures before alerting
ResetAfter: number; // Successes before clearing
// Alert Settings
AlertSeverity: number; // 1-4 severity level
AlertMessage: string; // Alert text template
AlertAction: string; // Action on alert
// Thresholds
Thresholds: MonitorThreshold[];
// Assignment
AssignmentType: string; // Group, Computer, Client
TargetID: number; // Target group/computer/client ID
// Template
TemplateID: number; // Parent template ID (0 if not from template)
// Metadata
Description: string; // Monitor description
DateCreated: string; // Creation date
DateModified: string; // Last modified
}
type MonitorType = 'Internal' | 'Remote' | 'Agent' | 'SNMP' | 'Script';
interface MonitorThreshold {
Field: string; // Field to check
Operator: ThresholdOperator; // Comparison operator
Value: string; // Threshold value
Duration: number; // Minutes condition must persist
}
type ThresholdOperator = 'eq' | 'ne' | 'gt' | 'lt' | 'ge' | 'le' | 'contains' | 'notcontains';
```
### Monitor Template Fields
```typescript
interface MonitorTemplate {
TemplateID: number; // Primary key
Name: string; // Template name
Description: string; // Template description
Category: string; // Template category
// Default Settings
MonitorType: MonitorType;
CheckInterval: number;
FailAfter: number;
ResetAfter: number;
AlertSeverity: number;
// Thresholds
Thresholds: MonitorThreshold[];
// Assignment Rules
AutoApply: boolean; // Auto-apply to new computers
ApplyCondition: string; // Condition for auto-apply
// Metadata
IsBuiltIn: boolean; // System template
DateCreated: string;
DateModified: string;
}
```
### Monitor Status Fields
```typescript
interface MonitorStatus {
MonitorID: number;
ComputerID: number;
Status: MonitorStatusValue;
LastCheck: string; // ISO datetime
LastAlertTime: string; // Last alert generated
ConsecutiveFailures: number; // Current failure count
CurrentValue: string; // Last checked value
Message: string; // Status message
}
type MonitorStatusValue = 'OK' | 'Warning' | 'Error' | 'Critical' | 'Unknown' | 'Disabled';
```
## API Patterns
### List All Monitor Templates
```http
GET /cwa/api/v1/Monitors/Templates?pageSize=100
Authorization: Bearer {token}
```
**Response:**
```json
[
{
"TemplateID": 1,
"Name": "CPU Usage - High",
"Category": "Performance",
"MonitorType": "Agent",
"CheckInterval": 300,
"AlertSeverity": 3,
"Description": "Alerts when CPU usage exceeds 90% for 10 minutes",
"Thresholds": [
{
"Field": "CPUUsage",
"Operator": "gt",
"Value": "90",
"Duration": 10
}
]
}
]
```
### Get Monitor Template Details
```http
GET /cwa/api/v1/Monitors/Templates/{templateID}
Authorization: Bearer {token}
```
### List Monitors for Computer
```http
GET /cwa/api/v1/Computers/{computerID}/Monitors
Authorization: Bearer {token}
```
**Response:**
```json
[
{
"MonitorID": 5001,
"Name": "Disk C: Free Space",
"MonitorType": "Agent",
"Status": "OK",
"LastCheck": "2024-02-15T10:30:00Z",
"CurrentValue": "45%",
"AlertSeverity": 2,
"Enabled": true
}
]
```
### Get Monitor Status for Computer
```http
GET /cwa/api/v1/Computers/{computerID}/Monitors/{monitorID}/Status
Authorization: Bearer {token}
```
**Response:**
```json
{
"MonitorID": 5001,
"ComputerID": 12345,
"Status": "Warning",
"LastCheck": "2024-02-15T10:30:00Z",
"ConsecutiveFailures": 2,
"CurrentValue": "8%",
"Message": "Disk C: is 8% free (threshold: 10%)"
}
```
### Create Monitor from Template
```http
POST /cwa/api/v1/Computers/{computerID}/Monitors
Authorization: Bearer {token}
Content-Type: application/json
{
"TemplateID": 1,
"Name": "CPU Usage - Custom",
"Thresholds": [
{
"Field": "CPUUsage",
"Operator": "gt",
"Value": "85",
"Duration": 15
}
]
}
```
### Create Custom Monitor
```http
POST /cwa/api/v1/Monitors
Authorization: Bearer {token}
Content-Type: application/json
{
"Name": "Custom Service Monitor",
"MonitorType": "Agent",
"Category": "Service",
"CheckInterval": 300,
"FailAfter": 2,
"ResetAfter": 1,
"AlertSeverity": 3,
"Thresholds": [
{
"Field": "ServiceStatus",
"Operator": "ne",
"Value": "Running"
}
],
"AssignmentType": "Group",
"TargetID": 10
}
```
### Update Monitor Threshold
```http
PATCH /cwa/api/v1/Monitors/{monitorID}
Authorization: Bearer {token}
Content-Type: application/json
{
"Thresholds": [
{
"Field": "DiskFreePercent",
"Operator": "lt",
"Value": "15",
"Duration": 0
}
]
}
```
### Assign Template to Group
```http
POST /cwa/api/v1/Groups/{groupID}/Monitors
Authorization: Bearer {token}
Content-Type: application/json
{
"TemplateID": 1
}
```
### Disable Monitor
```http
PATCH /cwa/api/v1/Monitors/{monitorID}
Authorization: Bearer {token}
Content-Type: application/json
{
"Enabled": false
}
```
### Delete Monitor
```http
DELETE /cwa/api/v1/Monitors/{monitorID}
Authorization: Bearer {token}
```
### List All Active Monitors with Status
```http
GET /cwa/api/v1/Monitors/Status?condition=Status ne 'OK'&pageSize=100
Authorization: Bearer {token}
```
## Workflows
### Create Disk Space Monitor
```javascript
async function createDiskSpaceMonitor(client, computerId, options = {}) {
const {
drive = 'C:',
warningThreshold = 15,
criticalThreshold = 5,
checkInterval = 300
} = options;
const monitor = await client.request('/Monitors', {
method: 'POST',
body: JSON.stringify({
Name: `Disk ${drive} Free Space`,
MonitorType: 'Agent',
Category: 'Performance',
CheckInterval: checkInterval,
FailAfter: 1,
ResetAfter: 1,
AlertSeverity: 2, // Warning
Thresholds: [
{
Field: 'DiskFreePercent',
Operator: 'lt',
Value: String(warningThreshold),
Duration: 0
}
],
AssignmentType: 'Computer',
TargetID: computerId
})
});
return monitor;
}
```
### Create Service Monitor
```javascript
async function createServiceMonitor(client, groupId, serviceName) {
const monitor = await client.request('/Monitors', {
method: 'POST',
body: JSON.stringify({
Name: `Service: ${serviceName}`,
MonitorType: 'Agent',
Category: 'Service',
CheckInterval: 300,
FailAfter: 2,
ResetAfter: 1,
AlertSeverity: 3, // Error
AlertMessage: `Service ${serviceName} is not running on %computername%`,
Thresholds: [
{
Field: 'ServiceStatus',
Operator: 'ne',
Value: 'Running'
}
],
AssignmentType: 'Group',
TargetID: groupId
})
});
return monitor;
}
```
### Get Failing Monitors for Client
```javascript
async function getFailingMonitors(client, clientId) {
// Get all computers for client
const computers = await client.request(
`/Clients/${clientId}/Computers?pageSize=500`
);
const failingMonitors = [];
for (const computer of computers) {
const monitors = await client.request(
`/Computers/${computer.ComputerID}/Monitors`
);
const failing = monitors.filter(m =>
['Warning', 'Error', 'Critical'].includes(m.Status)
);
if (failing.length > 0) {
failingMonitors.push({
computer: computer.Name,
computerId: computer.ComputerID,
monitors: failing.map(m => ({
name: m.Name,
status: m.Status,
value: m.CurrentValue,
lastCheck: m.LastCheck
}))
});
}
// Respect rate limits
await sleep(100);
}
return failingMonitors;
}
```
### Apply Template to All Servers
```javascript
async function applyTemplateToServers(client, templateId) {
// Get the template details
const template = await client.request(`/Monitors/Templates/${templateId}`);
// Get all servers
const servers = await client.request(
`/Computers?condition=OS contains 'Server'&pageSize=500`
);
const results = [];
for (const server of servers) {
try {
await client.request(`/Computers/${server.ComputerID}/Monitors`, {
method: 'POST',
body: JSON.stringify({ TemplateID: templateId })
});
results.push({
computer: server.Name,
status: 'applied'
});
} catch (error) {
results.push({
computer: server.Name,
status: 'failed',
error: error.message
});
}
await sleep(100);
}
return {
template: template.Name,
applied: results.filter(r => r.status === 'applied').length,
failed: results.filter(r => r.status === 'failed').length,
details: results
};
}
```
### Monitor Health Summary
```javascript
async function getMonitorHealthSummary(client) {
const statuses = await client.request('/Monitors/Status?pageSize=1000');
const summary = {
total: statuses.length,
ok: 0,
warning: 0,
error: 0,
critical: 0,
unknown: 0,
disabled: 0,
byCategory: {}
};
for (const status of statuses) {
switch (status.Status) {
case 'OK': summary.ok++; break;
case 'Warning': summary.warning++; break;
case 'Error': summary.error++; break;
case 'Critical': summary.critical++; break;
case 'Unknown': summary.unknown++; break;
case 'Disabled': summary.disabled++; break;
}
// Track by category
const category = status.Category || 'Uncategorized';
if (!summary.byCategory[category]) {
summary.byCategory[category] = { ok: 0, issues: 0 };
}
if (status.Status === 'OK') {
summary.byCategory[category].ok++;
} else {
summary.byCategory[category].issues++;
}
}
summary.healthPercentage = Math.round(
(summary.ok / (summary.total - summary.disabled)) * 100
);
return summary;
}
```
## Error Handling
### Common Monitor API Errors
| Error | Status | Cause | Resolution |
|-------|--------|-------|------------|
| Template not found | 404 | Invalid TemplateID | Verify template exists |
| Invalid threshold | 400 | Malformed threshold | Check threshold syntax |
| Monitor exists | 400 | Duplicate monitor | Use unique name |
| Permission denied | 403 | No access | Check user permissions |
| Invalid operator | 400 | Bad comparison operator | Use valid operator |
### Error Response Example
```json
{
"error": {
"code": "BadRequest",
"message": "Invalid threshold operator: 'greater'"
}
}
```
### Monitor Validation
```javascript
function validateMonitorDefinition(monitor) {
const errors = [];
if (!monitor.Name) {
errors.push('Monitor name is required');
}
if (!['Internal', 'Remote', 'Agent', 'SNMP', 'Script'].includes(monitor.MonitorType)) {
errors.push('Invalid monitor type');
}
if (monitor.CheckInterval < 60) {
errors.push('Check interval must be at least 60 seconds');
}
if (monitor.AlertSeverity < 1 || monitor.AlertSeverity > 4) {
errors.push('Alert severity must be 1-4');
}
const validOperators = ['eq', 'ne', 'gt', 'lt', 'ge', 'le', 'contains', 'notcontains'];
for (const threshold of monitor.Thresholds || []) {
if (!validOperators.includes(threshold.Operator)) {
errors.push(`Invalid threshold operator: ${threshold.Operator}`);
}
}
return {
valid: errors.length === 0,
errors
};
}
```
## Best Practices
1. **Use templates** - Standardize monitoring across environments
2. **Set appropriate intervals** - Balance responsiveness vs. load
3. **Configure FailAfter** - Avoid alert storms from transient issues
4. **Use groups for assignment** - Easier management than per-computer
5. **Document thresholds** - Record why specific values were chosen
6. **Test monitors** - Validate before broad deployment
7. **Review regularly** - Audit monitors for relevance
8. **Layer severity** - Warning before Error, Error before Critical
9. **Include context in alerts** - Use variables in alert messages
10. **Plan for maintenance** - Disable monitors during scheduled work
## Common Monitor Configurations
### CPU Usage Monitor
```javascript
{
Name: "CPU Usage - High",
MonitorType: "Agent",
Category: "Performance",
CheckInterval: 300,
FailAfter: 3,
ResetAfter: 2,
AlertSeverity: 2,
Thresholds: [
{ Field: "CPUUsage", Operator: "gt", Value: "90", Duration: 10 }
]
}
```
### Memory Usage Monitor
```javascript
{
Name: "Memory Usage - Critical",
MonitorType: "Agent",
Category: "Performance",
CheckInterval: 300,
FailAfter: 2,
ResetAfter: 1,
AlertSeverity: 3,
Thresholds: [
{ Field: "MemoryUsagePercent", Operator: "gt", Value: "95", Duration: 5 }
]
}
```
### Service Running Monitor
```javascript
{
Name: "Service: SQL Server",
MonitorType: "Agent",
Category: "Service",
CheckInterval: 180,
FailAfter: 1,
ResetAfter: 1,
AlertSeverity: 4,
Thresholds: [
{ Field: "ServiceStatus", Operator: "ne", Value: "Running" }
]
}
```
### Ping Monitor
```javascript
{
Name: "Ping: Gateway",
MonitorType: "Remote",
Category: "Network",
CheckInterval: 60,
FailAfter: 3,
ResetAfter: 2,
AlertSeverity: 3,
Thresholds: [
{ Field: "PingStatus", Operator: "ne", Value: "Success" }
]
}
```
## Related Skills
- [ConnectWise Automate Computers](../computers/SKILL.md) - Monitored computers
- [ConnectWise Automate Alerts](../alerts/SKILL.md) - Monitor-generated alerts
- [ConnectWise Automate Scripts](../scripts/SKILL.md) - Script monitors
- [ConnectWise Automate API Patterns](../api-patterns/SKILL.md) - Authentication and pagination