@gravito/zenith 1.1.2 → 1.1.6

package/src/server/services/MaintenanceScheduler.ts

@@ -1,78 +0,0 @@
-import type { Redis } from 'ioredis'
-
-export interface MaintenanceConfig {
-  autoCleanup: boolean
-  retentionDays: number
-  lastRun?: number
-}
-
-export class MaintenanceScheduler {
-  private static readonly ONE_DAY = 24 * 60 * 60 * 1000
-  private static readonly CHECK_INTERVAL = 3600000 // 1 hour
-
-  constructor(
-    private redis: Redis,
-    private cleanupCallback: (retentionDays: number) => Promise<number>
-  ) {}
-
-  /**
-   * Start the maintenance loop
-   */
-  start(initialDelay = 30000): void {
-    setTimeout(() => {
-      const loop = async () => {
-        try {
-          await this.checkMaintenance()
-        } catch (err) {
-          console.error('[Maintenance] Task Error:', err)
-        }
-        setTimeout(loop, MaintenanceScheduler.CHECK_INTERVAL)
-      }
-      loop()
-    }, initialDelay)
-  }
-
-  /**
-   * Check and run maintenance if needed
-   */
-  private async checkMaintenance(): Promise<void> {
-    const config = await this.getConfig()
-    if (!config.autoCleanup) {
-      return
-    }
-
-    const now = Date.now()
-    const lastRun = config.lastRun || 0
-
-    if (now - lastRun >= MaintenanceScheduler.ONE_DAY) {
-      console.log(
-        `[Maintenance] Starting Auto-Cleanup (Retention: ${config.retentionDays} days)...`
-      )
-      const deleted = await this.cleanupCallback(config.retentionDays)
-      console.log(`[Maintenance] Cleanup Complete. Removed ${deleted} records.`)
-
-      await this.saveConfig({
-        ...config,
-        lastRun: now,
-      })
-    }
-  }
-
-  /**
-   * Get maintenance configuration
-   */
-  async getConfig(): Promise<MaintenanceConfig> {
-    const data = await this.redis.get('gravito:zenith:maintenance:config')
-    if (data) {
-      return JSON.parse(data)
-    }
-    return { autoCleanup: false, retentionDays: 30 }
-  }
-
-  /**
-   * Save maintenance configuration
-   */
-  async saveConfig(config: MaintenanceConfig): Promise<void> {
-    await this.redis.set('gravito:zenith:maintenance:config', JSON.stringify(config))
-  }
-}

package/src/server/services/PulseService.ts

@@ -1,91 +0,0 @@
-import { Redis } from 'ioredis'
-import type { PulseNode } from '../../shared/types'
-
-/**
- * PulseService manages the discovery and health monitoring of system nodes.
- *
- * It scans Redis for heartbeat keys emitted by Quasar agents and groups
- * them by service name for the Zenith dashboard.
- *
- * @public
- * @since 3.0.0
- */
-export class PulseService {
-  private redis: Redis
-  private prefix = 'gravito:quasar:node:'
-
-  constructor(redisUrl: string) {
-    this.redis = new Redis(redisUrl, {
-      lazyConnect: true,
-    })
-  }
-
-  async connect() {
-    await this.redis.connect()
-  }
-
-  /**
-   * Discovers active Pulse nodes using SCAN.
-   */
-  async getNodes(): Promise<Record<string, PulseNode[]>> {
-    const nodes: PulseNode[] = []
-    let cursor = '0'
-    const now = Date.now()
-
-    do {
-      // Scan for pulse keys
-      const result = await this.redis.scan(cursor, 'MATCH', `${this.prefix}*`, 'COUNT', 100)
-      cursor = result[0]
-      const keys = result[1]
-
-      if (keys.length > 0) {
-        // Fetch values
-        const values = await this.redis.mget(...keys)
-
-        values.forEach((v) => {
-          if (v) {
-            try {
-              const node = JSON.parse(v) as PulseNode
-              // Filter out stale nodes if TTL didn't catch them yet (grace period 60s)
-              if (now - node.timestamp < 60000) {
-                nodes.push(node)
-              }
-            } catch (_e) {
-              // Ignore malformed
-            }
-          }
-        })
-      }
-    } while (cursor !== '0')
-
-    // Group by service
-    const grouped: Record<string, PulseNode[]> = {}
-
-    // Sort nodes by service name, then by node id for stable UI positions
-    nodes.sort((a, b) => {
-      const sComp = a.service.localeCompare(b.service)
-      if (sComp !== 0) {
-        return sComp
-      }
-      return a.id.localeCompare(b.id)
-    })
-
-    for (const node of nodes) {
-      if (!grouped[node.service]) {
-        grouped[node.service] = []
-      }
-      grouped[node.service].push(node)
-    }
-
-    return grouped
-  }
-
-  /**
-   * Manually record a heartbeat (for this Zenith server itself).
-   */
-  async recordHeartbeat(node: PulseNode): Promise<void> {
-    const key = `${this.prefix}${node.service}:${node.id}`
-    // TTL 30 seconds
-    await this.redis.set(key, JSON.stringify(node), 'EX', 30)
-  }
-}

package/src/server/services/QueueMetricsCollector.ts

@@ -1,138 +0,0 @@
-import type { Redis } from 'ioredis'
-import type { GlobalStats, QueueStats, WorkerReport } from './QueueService'
-
-export class QueueMetricsCollector {
-  constructor(
-    private redis: Redis,
-    private prefix = 'queue:'
-  ) {}
-
-  /**
-   * Discover all queues using SCAN to avoid blocking Redis
-   */
-  async listQueues(): Promise<QueueStats[]> {
-    const queues = new Set<string>()
-    let cursor = '0'
-    let iterations = 0
-    const MAX_ITERATIONS = 1000
-
-    do {
-      const result = await this.redis.scan(cursor, 'MATCH', `${this.prefix}*`, 'COUNT', 100)
-      cursor = result[0]
-      const keys = result[1]
-
-      for (const key of keys) {
-        const relative = key.slice(this.prefix.length)
-        const parts = relative.split(':')
-        const candidateName = parts[0]
-
-        if (candidateName && !this.isSystemKey(candidateName)) {
-          queues.add(candidateName)
-        }
-      }
-
-      iterations++
-    } while (cursor !== '0' && iterations < MAX_ITERATIONS)
-
-    return this.collectQueueStats(Array.from(queues).sort())
-  }
-
-  /**
-   * Collect statistics for a list of queues
-   */
-  private async collectQueueStats(queueNames: string[]): Promise<QueueStats[]> {
-    const stats: QueueStats[] = []
-    const BATCH_SIZE = 10
-
-    for (let i = 0; i < queueNames.length; i += BATCH_SIZE) {
-      const batch = queueNames.slice(i, i + BATCH_SIZE)
-      const batchResults = await Promise.all(batch.map(async (name) => this.getQueueStats(name)))
-      stats.push(...batchResults)
-    }
-
-    return stats
-  }
-
-  /**
-   * Get statistics for a single queue
-   */
-  private async getQueueStats(name: string): Promise<QueueStats> {
-    const waiting = await this.redis.llen(`${this.prefix}${name}`)
-    const delayed = await this.redis.zcard(`${this.prefix}${name}:delayed`)
-    const failed = await this.redis.llen(`${this.prefix}${name}:failed`)
-    const active = await this.redis.scard(`${this.prefix}${name}:active`)
-    const paused = await this.redis.get(`${this.prefix}${name}:paused`)
-
-    return {
-      name,
-      waiting,
-      delayed,
-      failed,
-      active,
-      paused: paused === '1',
-    }
-  }
-
-  /**
-   * Get global statistics including throughput
-   */
-  async getGlobalStats(): Promise<GlobalStats> {
-    const queues = await this.listQueues()
-    const throughput = await this.getThroughputData()
-
-    return {
-      queues,
-      throughput,
-      workers: [],
-    }
-  }
-
-  /**
-   * Get throughput data for the last hour
-   */
-  private async getThroughputData(): Promise<{ timestamp: string; count: number }[]> {
-    const data: { timestamp: string; count: number }[] = []
-    const currentMinute = Math.floor(Date.now() / 60000)
-
-    for (let i = 0; i < 60; i++) {
-      const minute = currentMinute - i
-      const count = await this.redis.get(`flux_console:throughput:${minute}`)
-      data.push({
-        timestamp: new Date(minute * 60000).toISOString(),
-        count: Number(count) || 0,
-      })
-    }
-
-    return data.reverse()
-  }
-
-  /**
-   * Get reports from all active workers
-   */
-  async listWorkers(): Promise<WorkerReport[]> {
-    const workers = await this.redis.smembers('flux_console:workers')
-
-    return Promise.all(workers.map(async (workerId) => this.getWorkerReport(workerId)))
-  }
-
-  /**
-   * Get report from a specific worker
-   */
-  private async getWorkerReport(workerId: string): Promise<WorkerReport> {
-    const data = await this.redis.get(`flux_console:worker:${workerId}`)
-
-    if (!data) {
-      throw new Error(`Worker ${workerId} not found`)
-    }
-
-    return JSON.parse(data) as WorkerReport
-  }
-
-  /**
-   * Check if a key is a system key
-   */
-  private isSystemKey(key: string): boolean {
-    const systemKeys = ['active', 'schedules', 'schedule', 'lock']
-    return systemKeys.includes(key)
-  }
-}