Auto-Discovery

Finding every running service on a server manually is time-consuming and error-prone—especially on inherited systems or large deployments. Auto-Discovery automates this process, scanning your servers and identifying all running services ready for monitoring.

Time Savings

Manual service detection: 1-2 hours per server
Auto-Discovery: 5-10 minutes automatic scan
Result: Spend time configuring monitoring, not hunting for services.

What Auto-Discovery Does

Auto-Discovery serves two purposes:

1. Automatic Uptime Check Creation

When Xitogent is installed on a server, Auto-Discovery:

Scans your server for active processes and listening ports
Identifies known services (databases, web servers, caches, queues, mail servers, etc.)
Detects software (Nginx, MySQL, Redis, Docker, RabbitMQ, etc.)
Automatically creates uptime checks for detected services
Starts monitoring immediately - no configuration needed

You can also trigger external IP scanning to auto-detect and create checks for services on your public IP without needing Xitogent installed.

2. Integration Recommendations

Auto-Discovery presents detected services as recommendations in the server view page:

Shows which integrations are available for the detected services
Allows you to manually enable integrations for deeper monitoring
Helps you decide which services to monitor without manual discovery

Timeline

Milestone	Timing	What's Happening
Xitogent installed	Instant	Agent registers with account
First data arrives	2-5 minutes	Basic metrics start flowing
Auto-Discovery starts	5 minutes	System scans for running services
Discovery completes	5-10 minutes	Uptime checks created automatically, recommendations shown
Integration enabled (optional)	< 1 minute	Manually enable for deeper metrics collection

Be patient: Discovery needs time to thoroughly scan. Don't refresh obsessively—give it 10 minutes and revisit.

What Can Be Discovered

Database Services

Auto-Discovery detects popular databases by scanning standard ports and processes:

MySQL - Port 3306, process: mysqld
PostgreSQL - Port 5432, process: postgres
MongoDB - Port 27017, process: mongod
Redis - Port 6379, process: redis-server
KeyDB - Port 6379, process: keydb-server
InfluxDB - Port 8086, process: influxd
CouchDB - Port 5984, process: couchdb
SQL Server - Port 1433, process: sqlservr

Web Servers & Proxies

Detects web serving software and reverse proxies:

Nginx - Port 80/443, process: nginx
Apache - Port 80/443, process: httpd or apache2
IIS - Windows web server
LiteSpeed - Port 80/443, process: lshttpd
OpenLiteSpeed - Process: openlitespeed
HAProxy - Load balancer, process: haproxy
Varnish - Cache, port 6081/6082, process: varnishd

Message Queues

Identifies message brokers and queuing systems:

RabbitMQ - Port 5672, process: rabbitmq
Kafka - Port 9092, process: kafka

System & Application Services

Detects containers, process managers, and network services:

Docker - Container runtime, process: dockerd
Supervisor - Process manager
PHP-FPM - PHP processor, process: php-fpm
CoreDNS - DNS server
WireGuard - VPN
OpenVPN - VPN
Postfix - Mail server
Dovecot - IMAP/POP3 server
**

Exim** - Mail transfer agent

Over 30 integrations supported - Browse complete list: All Integrations

How Auto-Discovery Works

Detection Methods

Auto-Discovery uses multiple techniques to identify services:

Port Scanning - Checks standard ports (3306 for MySQL, 6379 for Redis, etc.)
Process Detection - Scans running processes for known service names
Configuration Files - Reads config files to confirm service identity
Binary Detection - Locates installed binaries (/usr/bin/nginx, /usr/sbin/mysqld)
Package Manager - Queries package managers (apt, yum, dnf) for installed software

Non-intrusive: Auto-Discovery only reads system information. It doesn't modify configurations or restart services.

What About Non-Standard Configurations?

Services detected even when:

Running on custom ports (MySQL on 3307 instead of 3306)
Using custom binary names
Installed via source compile (not package manager)
Running in containers

May not detect:

Completely custom applications (your proprietary software)
Services running without standard process names
Heavily obscured or sandboxed services

Solution for missed services: Enable integrations manually from dashboard. See Integrations Guide.

Viewing Discovery Results

Accessing Discovery Results

Navigate to: Servers → [Your Server] → Server View (Auto-Discovery shows detected services as recommendations)

What You'll See:

Detected Services - List of identified software running on server
Integration Recommendations - Which integrations are available for detected services
Confidence Level - How certain discovery is (high/medium/low)
Port Information - Which ports each service uses
Auto-Created Uptime Checks - Services already being monitored

Result States

Uptime Check Auto-Created ✅

Service detected and uptime check automatically created
Service status being monitored
No action needed

Integration Recommended 🔵

Service detected, integration recommendation shown in server view
Click "Enable Integration" to start collecting detailed metrics (CPU, memory, connections, etc.)
Recommended to enable for deeper visibility

Manually Created ⚙️

Check or integration created manually without auto-discovery
Verify service still running if metrics missing

Enabling Integration Recommendations

Manual Integration Enable

From Server View Recommendations:

Go to Servers → [Your Server] → Server View
Review detected services and integration recommendations
Click "Enable Integration" next to service name
Integration activates
Detailed metrics start collecting within 5 minutes
View integration-specific metrics: Servers → [Your Server] → Integrations → [Service Name]

Service already being monitored - Auto-Discovery created an uptime check automatically. Integration enables deeper metrics collection.

Selective Enable

When to enable specific integrations:

First-time server setup (enable critical services first)
Standardized stack (enable same services on similar servers)
Cost/resource optimization (enable only what you need)

When to enable all:

Full infrastructure visibility required
Performance-adequate monitoring (low resource impact)
Compliance/audit requirements

When to skip:

Testing/dev servers with limited monitoring needs
Services you don't plan to monitor deeply
Integration doesn't apply to your setup

Understanding Discovery Limitations

What Auto-Discovery Can't Do

❌ Cannot detect:

Custom/proprietary applications (no known signatures)
Services intentionally hidden or obfuscated
Services that haven't started yet
Microservices running entirely in memory
Serverless functions (Lambda, Cloud Functions)

❌ Cannot configure:

Custom thresholds (use Auto-Triggers for recommended thresholds)
Notification routing (set up Notification Roles separately)
Authentication credentials (some integrations require manual credential setup)

Manual Integration Setup

When discovery misses a service or you want to monitor external services:

Go to Servers → [Your Server] → Integrations → Enable Integration
Select the integration type manually
Configure connection details (host, port, credentials if needed)
Save configuration
Verify metrics start appearing within 5-10 minutes

See integration-specific guides for setup details:

Discovery After Initial Scan

Continuous Re-Discovery

Auto-Discovery doesn't just run once:

Initial scan: 5-10 minutes after Xitogent install
Ongoing scans: Every 24 hours (daily)
After changes: Manually trigger re-scan

Why continuous discovery matters:

New services added to server (database installed later)
Services started that were previously stopped
Configuration changes (service moved to different port)
Software updates (new version detected)

Manual Re-Scan

Trigger discovery manually when:

You installed new software
Service configurations changed
Initial discovery incomplete
Troubleshooting missing integrations

How to manually trigger:

Servers → [Your Server] → Auto-Discovery
Click "Run Discovery Again"
Wait 5-10 minutes for scan to complete
Review updated results

Best Practices

After Discovery Completes

Review all discovered services - Verify accuracy (false positives rare but possible)
Enable relevant integrations - Don't enable everything if not needed
Wait for metrics - Give integrations 10-15 minutes to populate data
Configure triggers - Use Auto-Triggers for recommended thresholds
Set up notifications - Assign Notification Roles to important triggers

For Large Deployments

When monitoring many servers:

Let Auto-Discovery run on first server
Review results and document which integrations to enable
Use Ansible/automation to enable same integrations on remaining servers
Or let each server's Auto-Discovery run and bulk-enable standard services

For Inherited Infrastructure

Taking over unfamiliar servers:

Auto-Discovery reveals what's actually running
Compare discovery results against expected architecture
Identify "surprise" services (unknown software, backdoors, test services left running)
Document findings for infrastructure audit

Troubleshooting

Discovery Not Running

Symptoms: Server View shows "No scan results yet" after 15+ minutes

Solutions:

Verify Xitogent running:

# Linux
systemctl status xitogent

# Windows
Get-Service -Name Xitogent

Check agent logs:

tail -50 /var/log/xitogent.log
# Look for discovery-related errors

Manually trigger scan: Servers → [Your Server] → Server View → Auto-Discovery → "Run Discovery Again"
Verify network connectivity: Xitogent must reach xitoring.com to report results

See FAQ: Xitogent Troubleshooting for detailed debugging.

Service Not Detected

Symptoms: You know service is running, but Auto-Discovery didn't find it

Possible Causes:

Custom port: Service running on non-standard port (MySQL on 3307 not 3306)
Custom process name: Binary renamed or custom build
Containerized: Service inside container (Docker isolation)
Recently started: Service started after last discovery scan
Not yet supported: Software not in Auto-Discovery database

Solutions:

Trigger manual re-scan (service may have started after initial scan)
Enable integration manually - Servers → Integrations → Enable → Select Service
Check if integration exists - View All Integrations list
Request integration - Contact support if your software not supported

False Positive Detection

Symptoms: Discovery reports service not actually running

Possible Causes:

Service binary installed but service stopped
Leftover port listener from crashed process
Another service using same port

Solutions:

Verify service actually running: Check system processes
Don't enable that integration - Skip false positive services
Report issue - Help improve discovery accuracy

Common Scenarios

Scenario 1: First Server Setup

Timeline:

0:00 - Install Xitogent
0:02 - First metrics arrive
0:05 - Auto-Discovery starts
0:10 - Discovery completes, 8 services found, uptime checks auto-created
0:11 - Review integration recommendations in server view
0:12 - Enable integrations for services you want deep monitoring on
0:15 - Integration metrics start appearing
Day 2 - Auto-Trigger recommendations available (~24 hours after baseline)
Total: 20 minutes for initial monitoring; ~24 hours for Auto-Trigger recommendations (with automatic uptime checks for all services)

Scenario 2: New Service Installed

Example: You install Redis on monitored server

Approach 1 - Wait for daily scan:

Auto-Discovery detects Redis in next 24-hour scan
You see "New Services Detected" notification
Enable Redis integration

Approach 2 - Manual trigger:

Install Redis
Servers → [Your Server] → Server View → Auto-Discovery → "Run Discovery Again"
Wait 5-10 minutes
Enable Redis integration when discovered

Approach 3 - Manual enable:

Install Redis
Servers → Integrations → Enable Integration → Redis
Configure connection details
Start monitoring immediately (don't wait for discovery)

Scenario 3: Bulk Server Deployment

Deploy monitoring to 50 servers:

Install Xitogent on all servers (Ansible bulk deploy)
Wait 10-15 minutes for Auto-Discovery on all
Review first server's discovery results
Document standard services to enable (MySQL, Nginx, Redis)
Use API or Ansible to bulk-enable same services on remaining 49 servers
Verify all integrations reporting metrics