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.

How Integrations Work

Automatic Detection & Recommendations

1. Install Xitogent on your server
2. Auto-Discovery scans for running services (automatically, 5-10 minutes after install)
3. Uptime checks are created for detected services
4. Review integration recommendations in server view (Servers → [Your Server] → Server View)
5. Click "Enable Integration" for services you want deep monitoring on
6. 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

Platform Support

Most integrations support both Linux and Windows where applicable:

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:

1. Install Xitogent on server
2. Wait 10 minutes for Auto-Discovery scan
3. Dashboard → Servers → [Your Server] → Server View
4. Review integration recommendations for detected services
5. Click "Enable Integration" for services you want deep monitoring on
6. 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:

1. Dashboard → Servers → [Your Server] → Integrations tab
2. Click "Enable Integration"
3. Select integration from list (e.g., "MySQL")
4. Configure connection (most use localhost defaults):
   • Host: localhost or 127.0.0.1
   • Port: Default port for that service
   • Credentials: Optional (some integrations query without auth)
5. Click "Save"
6. 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:

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:

1. Servers → [Server] → Triggers → Create Trigger
2. Select integration metric (e.g., "MySQL - Slow Queries")
3. Set condition: >, <, =, ≥, ≤
4. Set threshold value: 10
5. Set Fault Tolerance: 5 minutes
6. Assign Notification Role
7. 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

1. Let Auto-Discovery run on all servers
2. Review what it found
3. Enable integrations for production-critical services first
4. 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:

1. Manually trigger re-scan:
   • Server → Auto-Discovery → "Run Discovery Again"
   • Wait 5-10 minutes
2. Enable manually:
   • Server → Integrations → Enable Integration → Select service
   • Configure connection details
3. 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:

1. Wait 10-15 minutes - First data collection takes time
2. Check integration status:
   • Server → Integrations → [Integration name]
   • Status shows "Connected" or error?
3. Verify credentials (if required):
   • Some integrations need read permissions
   • MySQL integration user needs PROCESS privilege
   • PostgreSQL needs pg_monitor role
4. Check service actually responding:

   # Test MySQL connection locally
   mysql -u root -p -e "SHOW STATUS"
   
5. 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!