update

internal/api/handlers.go

···
 			scanMap["response_time"] = scan.ResponseTime
 		}
 
-		// NEW: Add version if available
 		if scan.Version != "" {
 			scanMap["version"] = scan.Version
+		}
+
+		if scan.UsedIP != "" {
+			scanMap["used_ip"] = scan.UsedIP
 		}
 
 		// Use the top-level UserCount field first

internal/pds/client.go

···
 	"context"
 	"encoding/json"
 	"fmt"
+	"net"
 	"net/http"
 	"time"
 )
···
 }
 
 // CheckHealth performs a basic health check, ensuring the endpoint returns JSON with a "version"
-func (c *Client) CheckHealth(ctx context.Context, endpoint string) (bool, time.Duration, string, error) {
+// Returns: available, responseTime, version, usedIP, error
+func (c *Client) CheckHealth(ctx context.Context, endpoint string) (bool, time.Duration, string, string, error) {
 	startTime := time.Now()
 
 	url := fmt.Sprintf("%s/xrpc/_health", endpoint)
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		return false, 0, "", err
+		return false, 0, "", "", err
+	}
+
+	// Create a custom dialer to track which IP was actually used
+	var usedIP string
+	transport := &http.Transport{
+		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+			conn, err := (&net.Dialer{
+				Timeout:   30 * time.Second,
+				KeepAlive: 30 * time.Second,
+			}).DialContext(ctx, network, addr)
+
+			if err == nil && conn != nil {
+				if remoteAddr := conn.RemoteAddr(); remoteAddr != nil {
+					// Extract IP from "ip:port" format
+					if tcpAddr, ok := remoteAddr.(*net.TCPAddr); ok {
+						usedIP = tcpAddr.IP.String()
+					}
+				}
+			}
+
+			return conn, err
+		},
+	}
+
+	// Create a client with our custom transport
+	client := &http.Client{
+		Timeout:   c.httpClient.Timeout,
+		Transport: transport,
 	}
 
-	resp, err := c.httpClient.Do(req)
+	resp, err := client.Do(req)
 	duration := time.Since(startTime)
 
 	if err != nil {
-		return false, duration, "", err
+		return false, duration, "", usedIP, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		return false, duration, "", fmt.Errorf("health check returned status %d", resp.StatusCode)
+		return false, duration, "", usedIP, fmt.Errorf("health check returned status %d", resp.StatusCode)
 	}
 
 	// Decode the JSON response and check for "version"
···
 	}
 
 	if err := json.NewDecoder(resp.Body).Decode(&healthResponse); err != nil {
-		return false, duration, "", fmt.Errorf("failed to decode health JSON: %w", err)
+		return false, duration, "", usedIP, fmt.Errorf("failed to decode health JSON: %w", err)
 	}
 
 	if healthResponse.Version == "" {
-		return false, duration, "", fmt.Errorf("health JSON response missing 'version' field")
+		return false, duration, "", usedIP, fmt.Errorf("health JSON response missing 'version' field")
 	}
 
 	// All checks passed
-	return true, duration, healthResponse.Version, nil
+	return true, duration, healthResponse.Version, usedIP, nil
 }

internal/pds/scanner.go

···
 		go s.updateIPInfoIfNeeded(ctx, ips.IPv6)
 	}
 
-	// STEP 2: Health check (rest remains the same)
-	available, responseTime, version, err := s.client.CheckHealth(ctx, ep.Endpoint)
+	// STEP 2: Health check (now returns which IP was used)
+	available, responseTime, version, usedIP, err := s.client.CheckHealth(ctx, ep.Endpoint)
 	if err != nil || !available {
 		errMsg := "health check failed"
 		if err != nil {
···
 			Status:       storage.EndpointStatusOffline,
 			ResponseTime: responseTime,
 			ErrorMessage: errMsg,
+			UsedIP:       usedIP, // Save even if failed
 		})
 		return
 	}
···
 		Description:  desc,
 		DIDs:         dids,
 		Version:      version,
+		UsedIP:       usedIP, // NEW: Save which IP was used
 	})
 
 	// Save repos in batches (only tracks changes)
···
 		Metadata: make(map[string]interface{}),
 	}
 
-	var userCount int64 // NEW: Declare user count
+	var userCount int64
 
 	// Add PDS-specific metadata
 	if result.Status == storage.EndpointStatusOnline {
-		userCount = int64(len(result.DIDs))         // NEW: Get user count
-		scanData.Metadata["user_count"] = userCount // Keep in JSON for completeness
+		userCount = int64(len(result.DIDs))
+		scanData.Metadata["user_count"] = userCount
 		if result.Description != nil {
 			scanData.Metadata["server_info"] = result.Description
 		}
···
 		Status:       result.Status,
 		ResponseTime: result.ResponseTime.Seconds() * 1000, // Convert to ms
 		UserCount:    userCount,
-		Version:      result.Version, // NEW: Set the version field
+		Version:      result.Version,
+		UsedIP:       result.UsedIP, // NEW
 		ScanData:     scanData,
 		ScannedAt:    time.Now().UTC(),
 	}

internal/pds/types.go

···
 	ErrorMessage string
 	Description  *ServerDescription
 	DIDs         []string
-	Version      string // NEW: Add this field to pass the version
+	Version      string
+	UsedIP       string // NEW
 }

internal/storage/postgres.go

···
 	CREATE INDEX IF NOT EXISTS idx_ip_infos_country_code ON ip_infos(country_code);
 	CREATE INDEX IF NOT EXISTS idx_ip_infos_asn ON ip_infos(asn);
 
-    -- Endpoint scans (renamed from pds_scans)
+    -- Endpoint scans
 	CREATE TABLE IF NOT EXISTS endpoint_scans (
 		id BIGSERIAL PRIMARY KEY,
 		endpoint_id BIGINT NOT NULL,
···
 		response_time DOUBLE PRECISION,
 		user_count BIGINT,
 		version TEXT,
+		used_ip TEXT,
 		scan_data JSONB,
 		scanned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
 		FOREIGN KEY (endpoint_id) REFERENCES endpoints(id) ON DELETE CASCADE
···
 	CREATE INDEX IF NOT EXISTS idx_endpoint_scans_endpoint_status_scanned ON endpoint_scans(endpoint_id, status, scanned_at DESC);
 	CREATE INDEX IF NOT EXISTS idx_endpoint_scans_scanned_at ON endpoint_scans(scanned_at);
 	CREATE INDEX IF NOT EXISTS idx_endpoint_scans_user_count ON endpoint_scans(user_count DESC NULLS LAST);
+	CREATE INDEX IF NOT EXISTS idx_endpoint_scans_used_ip ON endpoint_scans(used_ip);
+
 
 	CREATE TABLE IF NOT EXISTS plc_metrics (
         id BIGSERIAL PRIMARY KEY,
···
 	defer tx.Rollback()
 
 	query := `
-		INSERT INTO endpoint_scans (endpoint_id, status, response_time, user_count, version, scan_data, scanned_at)
-		VALUES ($1, $2, $3, $4, $5, $6, $7)
+		INSERT INTO endpoint_scans (endpoint_id, status, response_time, user_count, version, used_ip, scan_data, scanned_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
 	`
-	_, err = tx.ExecContext(ctx, query, scan.EndpointID, scan.Status, scan.ResponseTime, scan.UserCount, scan.Version, scanDataJSON, scan.ScannedAt)
+	_, err = tx.ExecContext(ctx, query, scan.EndpointID, scan.Status, scan.ResponseTime, scan.UserCount, scan.Version, scan.UsedIP, scanDataJSON, scan.ScannedAt)
 	if err != nil {
 		return err
 	}
···
 
 func (p *PostgresDB) GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error) {
 	query := `
-        SELECT id, endpoint_id, status, response_time, user_count, version, scan_data, scanned_at
+        SELECT id, endpoint_id, status, response_time, user_count, version, used_ip, scan_data, scanned_at
         FROM endpoint_scans
         WHERE endpoint_id = $1
         ORDER BY scanned_at DESC
···
 		var scan EndpointScan
 		var responseTime sql.NullFloat64
 		var userCount sql.NullInt64
-		var version sql.NullString // NEW
+		var version, usedIP sql.NullString
 		var scanDataJSON []byte
 
-		err := rows.Scan(&scan.ID, &scan.EndpointID, &scan.Status, &responseTime, &userCount, &version, &scanDataJSON, &scan.ScannedAt)
+		err := rows.Scan(&scan.ID, &scan.EndpointID, &scan.Status, &responseTime, &userCount, &version, &usedIP, &scanDataJSON, &scan.ScannedAt)
 		if err != nil {
 			return nil, err
 		}
···
 			scan.UserCount = userCount.Int64
 		}
 
-		if version.Valid { // NEW
+		if version.Valid {
 			scan.Version = version.String
+		}
+
+		if usedIP.Valid {
+			scan.UsedIP = usedIP.String
 		}
 
 		if len(scanDataJSON) > 0 {

internal/storage/types.go

···
 	Status       int
 	ResponseTime float64
 	UserCount    int64
-	Version      string // NEW: Add this field
+	Version      string
+	UsedIP       string // NEW: Track which IP was actually used
 	ScanData     *EndpointScanData
 	ScannedAt    time.Time
 }