update

config.yaml

···
   index_dids: true
 
 pds:
-  scan_interval: "15m"
+  scan_interval: "30m"
   timeout: "30s"
   workers: 20
-  recheck_interval: "5m"
+  recheck_interval: "30m"
   scan_retention: 3
 
 api:

internal/monitor/tracker.go

···
+package monitor
+package monitor
+
+import (
+	"sync"
+	"time"
+)
+
+type JobStatus struct {
+	Name         string        `json:"name"`
+	Status       string        `json:"status"` // "idle", "running", "completed", "error"
+	StartTime    time.Time     `json:"start_time,omitempty"`
+	LastRun      time.Time     `json:"last_run,omitempty"`
+	Duration     time.Duration `json:"duration,omitempty"`
+	Progress     *Progress     `json:"progress,omitempty"`
+	Error        string        `json:"error,omitempty"`
+	NextRun      time.Time     `json:"next_run,omitempty"`
+	RunCount     int64         `json:"run_count"`
+	SuccessCount int64         `json:"success_count"`
+	ErrorCount   int64         `json:"error_count"`
+}
+
+type Progress struct {
+	Current int    `json:"current"`
+	Total   int    `json:"total"`
+	Percent float64 `json:"percent"`
+	Message string `json:"message,omitempty"`
+}
+
+type WorkerStatus struct {
+	ID          int       `json:"id"`
+	Status      string    `json:"status"` // "idle", "working"
+	CurrentTask string    `json:"current_task,omitempty"`
+	StartedAt   time.Time `json:"started_at,omitempty"`
+	Duration    time.Duration `json:"duration,omitempty"`
+}
+
+type Tracker struct {
+	mu      sync.RWMutex
+	jobs    map[string]*JobStatus
+	workers map[string][]WorkerStatus // key is job name
+}
+
+var globalTracker *Tracker
+
+func init() {
+	globalTracker = &Tracker{
+		jobs:    make(map[string]*JobStatus),
+		workers: make(map[string][]WorkerStatus),
+	}
+}
+
+func GetTracker() *Tracker {
+	return globalTracker
+}
+
+// Job status methods
+func (t *Tracker) RegisterJob(name string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	t.jobs[name] = &JobStatus{
+		Name:   name,
+		Status: "idle",
+	}
+}
+
+func (t *Tracker) StartJob(name string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	if job, exists := t.jobs[name]; exists {
+		job.Status = "running"
+		job.StartTime = time.Now()
+		job.Error = ""
+		job.RunCount++
+	}
+}
+
+func (t *Tracker) CompleteJob(name string, err error) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	if job, exists := t.jobs[name]; exists {
+		job.LastRun = time.Now()
+		job.Duration = time.Since(job.StartTime)
+		
+		if err != nil {
+			job.Status = "error"
+			job.Error = err.Error()
+			job.ErrorCount++
+		} else {
+			job.Status = "completed"
+			job.SuccessCount++
+		}
+		
+		job.Progress = nil // Clear progress
+	}
+}
+
+func (t *Tracker) UpdateProgress(name string, current, total int, message string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	if job, exists := t.jobs[name]; exists {
+		var percent float64
+		if total > 0 {
+			percent = float64(current) / float64(total) * 100
+		}
+		
+		job.Progress = &Progress{
+			Current: current,
+			Total:   total,
+			Percent: percent,
+			Message: message,
+		}
+	}
+}
+
+func (t *Tracker) SetNextRun(name string, nextRun time.Time) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	if job, exists := t.jobs[name]; exists {
+		job.NextRun = nextRun
+	}
+}
+
+func (t *Tracker) GetJobStatus(name string) *JobStatus {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	
+	if job, exists := t.jobs[name]; exists {
+		// Create a copy
+		jobCopy := *job
+		if job.Progress != nil {
+			progressCopy := *job.Progress
+			jobCopy.Progress = &progressCopy
+		}
+		
+		// Calculate duration for running jobs
+		if jobCopy.Status == "running" {
+			jobCopy.Duration = time.Since(jobCopy.StartTime)
+		}
+		
+		return &jobCopy
+	}
+	return nil
+}
+
+func (t *Tracker) GetAllJobs() map[string]*JobStatus {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	
+	result := make(map[string]*JobStatus)
+	for name, job := range t.jobs {
+		jobCopy := *job
+		if job.Progress != nil {
+			progressCopy := *job.Progress
+			jobCopy.Progress = &progressCopy
+		}
+		
+		// Calculate duration for running jobs
+		if jobCopy.Status == "running" {
+			jobCopy.Duration = time.Since(jobCopy.StartTime)
+		}
+		
+		result[name] = &jobCopy
+	}
+	return result
+}
+
+// Worker status methods
+func (t *Tracker) InitWorkers(jobName string, count int) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	workers := make([]WorkerStatus, count)
+	for i := 0; i < count; i++ {
+		workers[i] = WorkerStatus{
+			ID:     i + 1,
+			Status: "idle",
+		}
+	}
+	t.workers[jobName] = workers
+}
+
+func (t *Tracker) StartWorker(jobName string, workerID int, task string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	if workers, exists := t.workers[jobName]; exists && workerID > 0 && workerID <= len(workers) {
+		workers[workerID-1].Status = "working"
+		workers[workerID-1].CurrentTask = task
+		workers[workerID-1].StartedAt = time.Now()
+	}
+}
+
+func (t *Tracker) CompleteWorker(jobName string, workerID int) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	
+	if workers, exists := t.workers[jobName]; exists && workerID > 0 && workerID <= len(workers) {
+		workers[workerID-1].Status = "idle"
+		workers[workerID-1].CurrentTask = ""
+		workers[workerID-1].Duration = time.Since(workers[workerID-1].StartedAt)
+		workers[workerID-1].StartedAt = time.Time{}
+	}
+}
+
+func (t *Tracker) GetWorkers(jobName string) []WorkerStatus {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	
+	if workers, exists := t.workers[jobName]; exists {
+		// Create a copy with calculated durations
+		result := make([]WorkerStatus, len(workers))
+		for i, w := range workers {
+			result[i] = w
+			if w.Status == "working" && !w.StartedAt.IsZero() {
+				result[i].Duration = time.Since(w.StartedAt)
+			}
+		}
+		return result
+	}
+	return nil
+}

internal/pds/scanner.go

···
 	startTime := time.Now()
 	log.Info("Starting PDS availability scan...")
 
-	// Get only PDS endpoints
+	// Get only PDS endpoints that need checking (stale or never checked)
 	servers, err := s.db.GetEndpoints(ctx, &storage.EndpointFilter{
-		Type: "pds",
+		Type:            "pds",
+		OnlyStale:       true,                     // NEW: Only get stale endpoints
+		RecheckInterval: s.config.RecheckInterval, // NEW: Use recheck interval from config
 	})
 	if err != nil {
 		return err
 	}
 
-	// 2. ADD THIS BLOCK TO SHUFFLE THE LIST
+	if len(servers) == 0 {
+		log.Info("No endpoints need scanning at this time")
+		return nil
+	}
+
+	log.Info("Found %d endpoints that need scanning (not checked in last %s)", len(servers), s.config.RecheckInterval)
+
+	// Shuffle the servers slice in place
 	if len(servers) > 0 {
-		// Create a new random source to avoid using the global one
 		r := rand.New(rand.NewSource(time.Now().UnixNano()))
-		// Shuffle the servers slice in place
 		r.Shuffle(len(servers), func(i, j int) {
 			servers[i], servers[j] = servers[j], servers[i]
 		})
 		log.Info("Randomized scan order for %d PDS servers...", len(servers))
-	} else {
-		log.Info("Scanning 0 PDS servers...")
-		return nil // No need to continue if there are no servers
 	}
 
 	// Worker pool

internal/storage/postgres.go

···
 			args = append(args, statusInt)
 			argIdx++
 		}
+
+		// NEW: Filter for stale endpoints only
+		if filter.OnlyStale && filter.RecheckInterval > 0 {
+			query += fmt.Sprintf(" AND (last_checked IS NULL OR last_checked < NOW() - INTERVAL '%d seconds')", int(filter.RecheckInterval.Seconds()))
+		}
 	}
 
 	query += " ORDER BY id DESC"

internal/storage/types.go

···
 
 // EndpointFilter for querying endpoints
 type EndpointFilter struct {
-	Type         string // "pds", "labeler", etc.
-	Status       string
-	MinUserCount int64
-	Limit        int
-	Offset       int
+	Type            string // "pds", "labeler", etc.
+	Status          string
+	MinUserCount    int64
+	OnlyStale       bool          // NEW: Only return endpoints that need re-checking
+	RecheckInterval time.Duration // NEW: How long before an endpoint is considered stale
+	Limit           int
+	Offset          int
 }
 
 // EndpointStats contains aggregate statistics about endpoints