Monitoring

type Stats struct {
    // Memory usage in bytes
    Memory uint64 `json:"memory_bytes"`
    
    // Memory limit in bytes
    MemoryLimit uint64 `json:"memory_limit_bytes"`
    
    // Absolute CPU usage across entire system
    CpuAbsolute float64 `json:"cpu_absolute"`
    
    // Network statistics
    Network NetworkStats `json:"network"`
    
    // Container uptime in milliseconds
    Uptime int64 `json:"uptime"`
}

type NetworkStats struct {
    RxBytes uint64 `json:"rx_bytes"`
    TxBytes uint64 `json:"tx_bytes"`
}

type ResourceUsage struct {
    mu sync.RWMutex
    
    // Embedded environment stats
    environment.Stats
    
    // Current server state
    State *system.AtomicString `json:"state"`
    
    // Disk usage in bytes (cached value)
    Disk int64 `json:"disk_bytes"`
}

func (s *Server) Proc() ResourceUsage {
    s.resources.mu.Lock()
    defer s.resources.mu.Unlock()
    
    // Update disk usage from cache
    atomic.StoreInt64(&s.resources.Disk, s.Filesystem().CachedUsage())
    
    return s.resources
}

func (ru *ResourceUsage) UpdateStats(stats environment.Stats) {
    ru.mu.Lock()
    ru.Stats = stats
    ru.mu.Unlock()
}

GET /api/servers/{server}

type APIResponse struct {
    State         string        `json:"state"`
    IsSuspended   bool          `json:"is_suspended"`
    Utilization   ResourceUsage `json:"utilization"`
    Configuration Configuration `json:"configuration"`
}

func (s *Server) ToAPIResponse() APIResponse {
    return APIResponse{
        State:         s.Environment.State(),
        IsSuspended:   s.IsSuspended(),
        Utilization:   s.Proc(),
        Configuration: *s.Config(),
    }
}

s.Events().Publish(StatsEvent, s.Proc())

func (s *Server) OnStateChange() {
    prevState := s.resources.State.Load()
    st := s.Environment.State()
    
    // Update tracked state
    s.resources.State.Store(st)
    
    // Publish state change event
    if prevState != s.Environment.State() {
        s.Log().WithField("status", st).Debug("saw server status change event")
        s.Events().Publish(StatusEvent, st)
    }
    
    // Reset stats when offline
    if st == environment.ProcessOfflineState {
        s.resources.Reset()
        s.Events().Publish(StatsEvent, s.Proc())
    }
}

Memory uint64 `json:"memory_bytes"`

MemoryLimit uint64 `json:"memory_limit_bytes"`

CpuAbsolute float64 `json:"cpu_absolute"`

RxBytes uint64 `json:"rx_bytes"`

TxBytes uint64 `json:"tx_bytes"`

Disk int64 `json:"disk_bytes"`

atomic.StoreInt64(&s.resources.Disk, s.Filesystem().CachedUsage())

Uptime int64 `json:"uptime"`

func (ru *ResourceUsage) Reset() {
    ru.mu.Lock()
    defer ru.mu.Unlock()
    
    ru.Memory = 0
    ru.CpuAbsolute = 0
    ru.Uptime = 0
    ru.Network.TxBytes = 0
    ru.Network.RxBytes = 0
}

func (s *Server) IsRunning() bool {
    st := s.Environment.State()
    return st == environment.ProcessRunningState || st == environment.ProcessStartingState
}

State *system.AtomicString `json:"state"`

// Use Proc() to get current stats
stats := server.Proc()
if stats.Memory > stats.MemoryLimit {
    // Handle out of memory
}

// Don't access s.resources directly
// This bypasses mutex protection and disk update
memory := server.resources.Memory // Unsafe!

ws.addEventListener('message', (event) => {
  const data = JSON.parse(event.data);
  
  if (data.event === 'stats') {
    const stats = JSON.parse(data.args[0]);
    console.log('Memory:', stats.memory_bytes);
    console.log('CPU:', stats.cpu_absolute);
    console.log('Network RX:', stats.network.rx_bytes);
    console.log('Network TX:', stats.network.tx_bytes);
  }
});

const memoryPercent = (stats.memory_bytes / stats.memory_limit_bytes) * 100;
console.log(`Memory: ${memoryPercent.toFixed(1)}%`);

// CPU is already a percentage
console.log(`CPU: ${stats.cpu_absolute.toFixed(1)}%`);

let lastStats = null;
let lastTime = null;

function updateNetworkRate(stats) {
  const now = Date.now();
  
  if (lastStats && lastTime) {
    const timeDelta = (now - lastTime) / 1000; // seconds
    const rxDelta = stats.network.rx_bytes - lastStats.network.rx_bytes;
    const txDelta = stats.network.tx_bytes - lastStats.network.tx_bytes;
    
    const rxRate = rxDelta / timeDelta; // bytes/sec
    const txRate = txDelta / timeDelta; // bytes/sec
    
    console.log(`RX: ${(rxRate / 1024).toFixed(1)} KB/s`);
    console.log(`TX: ${(txRate / 1024).toFixed(1)} KB/s`);
  }
  
  lastStats = stats;
  lastTime = now;
}

const diskGB = stats.disk_bytes / (1024 * 1024 * 1024);
console.log(`Disk: ${diskGB.toFixed(2)} GB`);

const uptimeSeconds = stats.uptime / 1000;
const hours = Math.floor(uptimeSeconds / 3600);
const minutes = Math.floor((uptimeSeconds % 3600) / 60);
console.log(`Uptime: ${hours}h ${minutes}m`);

# pseudo-code
for server in wings.servers:
    stats = server.proc()
    
    prometheus.gauge(f'server_memory_bytes', stats.memory_bytes, 
                     labels={'server': server.id})
    prometheus.gauge(f'server_cpu_percent', stats.cpu_absolute,
                     labels={'server': server.id})
    prometheus.counter(f'server_network_rx_bytes', stats.network.rx_bytes,
                       labels={'server': server.id})
    prometheus.counter(f'server_network_tx_bytes', stats.network.tx_bytes,
                       labels={'server': server.id})

-- Example Grafana query (pseudo-code)
SELECT
  time,
  server_id,
  memory_bytes / memory_limit_bytes * 100 as memory_percent,
  cpu_absolute,
  network_rx_bytes,
  network_tx_bytes
FROM wings_stats
WHERE time > now() - 1h

# Memory usage > 90%
- alert: HighMemoryUsage
  expr: (server_memory_bytes / server_memory_limit_bytes) > 0.9
  for: 5m

# CPU usage > 200% (2 cores)
- alert: HighCPUUsage
  expr: server_cpu_absolute > 200
  for: 10m

# Server offline
- alert: ServerOffline
  expr: server_state == "offline"
  for: 1m

docker stats {container_id}