Integrations
Beyond basic server metrics (CPU, memory, disk), integrations provide deep monitoring of specific software running on your servers. Get database query performance, web server request rates, cache hit ratios, queue depths, and hundreds of technology-specific metrics.
Auto-Discovery Makes This Easy
Don't manually hunt for what software is running—Auto-Discovery automatically detects services, creates uptime checks, and shows integration recommendations in the server view. Enable integrations only when you want deep metrics.
How Integrations Work
Automatic Detection & Recommendations
- Install Xitogent on your server
- Auto-Discovery scans for running services (automatically, 5-10 minutes after install)
- Uptime checks are created for detected services
- Review integration recommendations in server view (Servers → [Your Server] → Server View)
- Click "Enable Integration" for services you want deep monitoring on
- Integration metrics appear within 5-10 minutes
No configuration files, no manual setup - Most integrations work automatically once enabled.
What You Get
Each integration provides:
- Technology-specific metrics - Queries/sec, connection pools, cache hits, request rates
- Performance insights - Slow queries, error rates, latency percentiles
- Resource utilization - Per-service CPU/memory (not just server-wide)
- Recommended triggers - Auto-Triggers suggests intelligent thresholds
- Historical graphs - Trend analysis, capacity planning, incident correlation
Available Integrations (30+)
Databases
Relational Databases:
- MySQL - Connections, queries/sec, slow queries, replication lag, InnoDB metrics
- PostgreSQL - Connections, transactions, locks, WAL, vacuum operations
- SQL Server - Batch requests, connections, locks, buffer cache hit ratio
NoSQL & Document Stores:
- MongoDB - Operations, connections, replica set health, oplog window
- CouchDB - Document operations, view requests, replication status
- InfluxDB - Series cardinality, writes/reads, query performance
Key-Value & Caching:
- Redis - Memory usage, evictions, keys, commands/sec, replication lag
- KeyDB - Redis-compatible metrics plus KeyDB-specific features
Web Servers & Proxies
Web Servers:
- Nginx - Requests/sec, active connections, upstream health, response times
- Apache - Requests, workers, CPU usage, scoreboard status
- IIS - Requests, connections, app pool health (Windows)
- LiteSpeed - Connections, requests, cache performance
- OpenLiteSpeed - LiteSpeed open-source variant
Reverse Proxies & Load Balancers:
- HAProxy - Backend health, session rate, response times, queue depth
- Varnish - Cache hits/misses, backend requests, purges, bans
Application Servers:
- PHP-FPM - Active processes, slow requests, queue length
Message Queues & Streaming
- RabbitMQ - Queue depth, message rate, connections, consumer count
- Kafka - Partition lag, throughput, broker metrics, topic health
Infrastructure & Services
Containers:
- Docker - Container count, resource usage per container, image stats
Process Management:
- Supervisor - Process status, uptime, restart count
Mail Servers:
- Postfix - Queue size, delivery rate, bounces, deferred mail
- Dovecot - IMAP/POP3 connections, mailbox operations, logins
- Exim - Message queue, delivery statistics, routing metrics
VPN:
- OpenVPN - Connected clients, bytes transferred, connection duration
- WireGuard - Peer status, handshakes, transfer statistics
DNS:
- CoreDNS - Query rate, cache hits, DNSSEC metrics
System Monitoring:
- Netstat - Network connections, listening ports, connection states
- Disk Monitoring - SMART health status, disk temperature, pending sectors
Integration Categories at a Glance
| Category | Integrations | Common Use Case |
|---|---|---|
| Databases | MySQL, PostgreSQL, MongoDB, Redis, SQL Server, CouchDB, InfluxDB, KeyDB | Monitor query performance, connection pools, slow queries |
| Web Servers | Nginx, Apache, IIS, LiteSpeed, OpenLiteSpeed | Track requests/sec, response times, worker utilization |
| Proxies/LB | HAProxy, Varnish | Backend health, cache efficiency, load distribution |
| Queue/Stream | RabbitMQ, Kafka | Queue depth, throughput, consumer lag |
| Postfix, Dovecot, Exim | Delivery rates, queue size, connection health | |
| Infrastructure | Docker, Supervisor, Netstat, Disk Health | Container resources, process supervision, network/disk health |
| VPN/Network | OpenVPN, WireGuard, CoreDNS | Client connections, DNS query performance |
| Application | PHP-FPM | Application server performance |
Platform Support
Most integrations support both Linux and Windows where applicable:
| Integration | Linux | Windows | Notes |
|---|---|---|---|
| MySQL | ✅ | ✅ | |
| PostgreSQL | ✅ | ✅ | |
| SQL Server | ✅ | ✅ | Native on Windows, docker/Linux supported |
| MongoDB | ✅ | ✅ | |
| Redis | ✅ | ❌ | Linux-focused (use WSL on Windows) |
| Nginx | ✅ | ✅ | |
| Apache | ✅ | ✅ | |
| IIS | ❌ | ✅ | Windows-only |
| Docker | ✅ | ❌ | Linux-focused |
| HAProxy | ✅ | ✅ | |
| RabbitMQ | ✅ | ✅ | |
| Kafka | ✅ | ✅ | |
| Varnish | ✅ | ❌ | Linux-only |
| Supervisor | ✅ | ❌ | Linux process manager |
| Postfix | ✅ | ❌ | Linux/Unix mail server |
| PHP-FPM | ✅ | ✅ | |
| Disk Monitoring | ✅ | ✅ | SMART health on both platforms |
| Netstat | ✅ | ✅ | Network connection stats |
See individual integration pages for detailed platform-specific instructions.
Enabling Integrations
Via Auto-Discovery (Recommended)
Easiest method - Let Xitoring find your software automatically and create uptime checks:
- Install Xitogent on server
- Wait 10 minutes for Auto-Discovery scan
- Dashboard → Servers → [Your Server] → Server View
- Review integration recommendations for detected services
- Click "Enable Integration" for services you want deep monitoring on
- Metrics appear within 5-10 minutes
Example:
Server View Recommendations:
✓ MySQL (Port 3306) - [Enable Integration]
✓ Nginx (Port 80) - [Enable Integration]
✓ Redis (Port 6379) - [Enable Integration]
Enable integrations per service for deep monitoring.
Manual Setup
When Auto-Discovery doesn't detect your service:
- Dashboard → Servers → [Your Server] → Integrations tab
- Click "Enable Integration"
- Select integration from list (e.g., "MySQL")
- Configure connection (most use localhost defaults):
- Host:
localhostor127.0.0.1 - Port: Default port for that service
- Credentials: Optional (some integrations query without auth)
- Host:
- Click "Save"
- Verify metrics appearing within 10 minutes
When to use manual setup:
- Service on non-standard port (MySQL on 3307 instead of 3306)
- Service in Docker container (network isolation may require config)
- Custom service name/configuration
- Auto-Discovery missed it (re-run discovery first, then manual if still missing)
See integration-specific documentation for detailed setup instructions.
Understanding Integration Metrics
Example: MySQL Integration
What you see after enabling:
Connection Metrics:
- Active connections (current)
- Max connections (configured)
- Connection rate (new connections/sec)
- Aborted connections (failed login attempts)
Query Performance:
- Queries per second
- Slow queries (queries exceeding
long_query_time) - Query cache hits vs misses
- Table locks waited (contention)
Replication (if configured):
- Replica lag (seconds behind master)
- Replication status (running/stopped)
- Binary log position
InnoDB Engine:
- Buffer pool usage (% of configured size)
- Rows read vs written
- Deadlocks detected
Each metric graphed over time - Spot trends, identify performance degradation, correlate with incidents.
Example: Nginx Integration
Request Metrics:
- Requests per second
- Active connections (reading, writing, waiting)
- Accepted vs handled connections
Upstream Health (if load balancing):
- Backend response times
- Backend failures
- Active backends
Response Codes:
- 2xx (success)
- 4xx (client errors)
- 5xx (server errors)
Integration-Specific Triggers
Auto-Triggers for Integrations
When you enable an integration, Auto-Triggers automatically creates recommended alerts:
MySQL Auto-Triggers Example:
| Metric | Recommended Threshold | Why |
|---|---|---|
| Connections | > 150 (if baseline is ~50) | High connection count may indicate leak or attack |
| Slow Queries | > 10/min (if baseline is ~2/min) | Performance degradation indicator |
| Replica Lag | > 60 seconds | Data consistency risk |
| Aborted Connections | > 5/min | Potential brute-force attack |
You can accept, customize, or ignore these recommendations - They're starting points based on your actual usage patterns.
Custom Triggers
Create integration-specific triggers manually:
- Servers → [Server] → Triggers → Create Trigger
- Select integration metric (e.g., "MySQL - Slow Queries")
- Set condition:
>,<,=,≥,≤ - Set threshold value:
10 - Set Fault Tolerance:
5 minutes - Assign Notification Role
- Save
Example custom triggers:
- Alert if Redis memory > 90% (eviction imminent)
- Alert if RabbitMQ queue depth > 10,000 (consumer lag)
- Alert if Nginx upstream all down (total backend failure)
- Alert if PostgreSQL connections > 95% of max (connection exhaustion)
Best Practices
Enable Strategically
Don't enable every integration blindly:
- ✅ Production databases - Critical to monitor (MySQL, PostgreSQL, Redis)
- ✅ Customer-facing web servers - Performance directly impacts users (Nginx, Apache)
- ✅ Message queues - Backlog can cascade failures (RabbitMQ, Kafka)
- ⏸️ Dev/test instances - Lower priority, save monitoring quota
- ❌ Unused software - Don't enable integration for service not actually being used
Rule: Monitor what matters to your application's health and user experience.
Start with Auto-Discovery
- Let Auto-Discovery run on all servers
- Review what it found
- Enable integrations for production-critical services first
- Gradually enable others as you expand monitoring
Monitor Integration Health
Integrations can fail:
- Database credentials expire
- Service moves to different port
- Firewall blocks monitoring queries
Dashboard shows integration status:
- ✅ Green: Collecting metrics normally
- ⚠️ Yellow: Some metrics missing (partial failure)
- ❌ Red: Integration offline (connection failed)
Fix broken integrations:
- Server → Integrations → Click on failing integration
- Review error message ("Connection refused on port 3306")
- Update configuration (fix credentials, port, etc.)
- Re-test connection
Troubleshooting
Integration Not Appearing in Auto-Discovery
Service is running, but Auto-Discovery didn't detect it:
Possible causes:
- Non-standard port (MySQL on 3307 instead of 3306)
- Service recently started (discovery runs periodically)
- Service in Docker (network isolation)
- Custom process name
Solutions:
- Manually trigger re-scan:
- Server → Auto-Discovery → "Run Discovery Again"
- Wait 5-10 minutes
- Enable manually:
- Server → Integrations → Enable Integration → Select service
- Configure connection details
- Verify service actually running:
# Check if MySQL running systemctl status mysql netstat -tlnp | grep 3306
Integration Enabled But No Metrics
Integration shows "Enabled" but graphs empty:
Checklist:
- Wait 10-15 minutes - First data collection takes time
- Check integration status:
- Server → Integrations → [Integration name]
- Status shows "Connected" or error?
- Verify credentials (if required):
- Some integrations need read permissions
- MySQL integration user needs
PROCESSprivilege - PostgreSQL needs
pg_monitorrole
- Check service actually responding:
# Test MySQL connection locally mysql -u root -p -e "SHOW STATUS" - Review Xitogent logs:
sudo tail -100 /var/log/xitogent.log | grep -i "integration\|error"
See individual integration documentation for specific troubleshooting.
High Integration Overhead
Concerned about monitoring impact on service performance:
Impact is minimal:
- Integration queries run every 60 seconds (default)
- Queries are lightweight (
SHOW STATUS, not table scans) - Read-only operations (never modify data)
- Typical overhead: <0.1% CPU, <10MB memory
If you're paranoid:
- Check service logs for monitoring queries (shouldn't appear in slow query log)
- Monitor your monitoring (compare service metrics before/after integration enabled)
- Adjust collection interval (increase from 60s to 120s if absolutely necessary)
In practice: Monitoring 100+ integrations on single server with no measurable performance impact.
See Also
Core Documentation:
- Auto-Discovery - Automatic service detection
- Auto-Triggers - Integration-specific alert recommendations
- Server Monitoring - Understanding server-wide metrics
- Xitogent - Installing the agent that enables integrations
Workflows:
- Monitor Your First Server - Complete setup including integration enablement
- Getting Started - High-level onboarding overview
Help:
- FAQ: Integrations - Common integration questions
- Glossary: Integration - Term definition
Next Step: Install Xitogent on your servers, let Auto-Discovery detect running services, then enable integrations with one click!