ReSysTor

As a developer, you'd often find yourself opening the system monitor to see how the system is managing processes. In my case, I had a separate physical device running heavy processes (my mini server because I can't afford AWS -_-) and needed to constantly check on it. Being experimental and curious, I tried building a simple system monitor that could be remotely accessed without having to set up industry-standard monitoring tools.

Features

By simple I mean dead simple, it needs to be able to:

Read the resources I check on i.e CPU and RAM usage
Be accessed remotely

Dead simple. No kidding.

The stack

Nextjs with Typescript for the fancy web UI
Go (Go lang) for the CLI
LocalTunnel to expose it on the internet

The plan

The frontend

Fetch the config

useEffect(() => {
    (async () => {
      const res = await fetch(`http://localhost:8080/config`, {
        cache: "no-cache",
      });

      const config = (await res.json()) as ServerConfig;

      setConfig(config);
    })();
  }, []);

The config contains the server's name and the interval, how long until it refreshes.

Now that we have the config, we need to fetch the initial data and keep re-fetching after each interval we got from the config

const getData = async () => {
    const res = await fetch(`http://localhost:8080`);

    const data = await res.json();

    setMontitorData(data);
  };

  useEffect(() => {
    getData();

    const ms = parseInt(interval) * 1000;

    const intervalFn = setInterval(() => getData(), ms);

    return () => clearInterval(intervalFn);
  }, []);

The data returns the following

interface MonitorData {
  filesystems: Filesystem[];
  processes: Process[];
  resources: Resources;
}

interface Filesystem {
  path: string;
  disk_type: string;
  device: string;
  total: number;
  free: number;
  used: number;
  used_percentage: number;
}

interface Process {
  name: string;
  username: string;
  pid: number;
  memory_usage: number;
  cpu_usage: number;
}

interface Resources {
  local_ip: string;
  uptime: Uptime;
  battery_stats: BatteryStats;
  memory_stats: MemoryStats;
  cpu_stats: CpuStats;
  user_meta: UserMeta;
}

interface Uptime {
  days: number;
  hours: number;
  minutes: number;
}

interface BatteryStats {
  charging_state: string;
  current_power: number;
}

interface MemoryStats {
  total: number;
  used: number;
  free: number;
  used_percentage: number;
}

interface CpuStats {
  model: string;
  cores: number;
  usages: number[];
}

interface UserMeta {
  name: string;
}

The CLI

We need to ship the UI together with final binary, luckily, Go makes it simple (as it does with all others)

//go:embed all:frontend/out
var assets embed.FS

Now when the program runs, we have access to files we can extract to host

if err := fs.WalkDir(assets, ".", func(path string, d fs.DirEntry, err error) error {
    if err != nil {
        return err
    }

    outPath := filepath.Join(tempDir, path)

    if d.IsDir() {
        return os.MkdirAll(outPath, 0755)
    }

    data, err := assets.ReadFile(path)
    if err != nil {
        return err
    }

    return os.WriteFile(outPath, data, 0644)
}); err != nil {
    log.Fatal(err)
}

Let’s serve it up locally using, well, serve at the location of the web files.

cmd := exec.Command("npx", "--yes", "serve", "-s", fmt.Sprintf("%v/frontend/out", currentDir))

We listen to status updates from the serve program at an interval of 5 seconds.

If its ready, fire up Localtunnel and listen on the running local port, 3000

for range time.Tick(time.Second * 5) {
		if strings.Contains(stdBuffer.String(), "Accepting") {
			log.Println("Getting tunnel url")
			cmd := exec.Command("npx", "--yes", "localtunnel", "--port", "3000")
			go cmd.Run()
			break
		}
	}

Now we can get our data using Gopsutil and battery. We import them.

import (
	"github.com/distatus/battery"
	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/disk"
	"github.com/shirou/gopsutil/mem"
	"github.com/shirou/gopsutil/process"
)

Getting the system resources

func (m *Monitor) GetSystemResources() (data.SystemResources, error) {
	stats := data.SystemResources{}

	memoryStats, err := mem.VirtualMemory()
	if err != nil {
		return stats, err
	}

	cpuInfo, err := cpu.Info()
	if err != nil {
		return stats, err
	}

	cpuUsages, err := cpu.Percent(0, true)
	if err != nil {
		return stats, err
	}

	upTime, err := utils.GetUptime()

	if err != nil {
		upTime = data.UpTime{}
	} else {
		stats.UpTime = upTime
	}

	stats.MemoryStats.Total = memoryStats.Total
	stats.MemoryStats.Free = memoryStats.Free
	stats.MemoryStats.Used = memoryStats.Used
	stats.MemoryStats.UsedPercentage = memoryStats.UsedPercent

	stats.CPUStats = data.CPUStats{
		Model:  cpuInfo[0].ModelName,
		Cores:  len(cpuInfo),
		Usages: cpuUsages,
	}

	batteries, err := battery.GetAll()
	if err != nil {
		stats.BatteryStats.CurrentPower = 0
		stats.BatteryStats.ChargingState = "Unknown"
	} else if len(batteries) > 0 {
		batteryStats := batteries[0]

		stats.BatteryStats.CurrentPower = int(math.Round(batteryStats.Current / batteryStats.Full * 100))
		stats.BatteryStats.ChargingState = batteryStats.State.String()
	} else {

		stats.BatteryStats.CurrentPower = 100
		stats.BatteryStats.ChargingState = "Full"

	}

	ip, err := utils.GetLocalIp()
	if err != nil {
		return stats, err
	}

	stats.LocalIP = ip

	return stats, nil
}

Getting system processes

func (m *Monitor) GetSystemProcesses() ([]data.Process, error) {
	stats := []data.Process{}

	allProcesses, err := process.Processes()
	if err != nil {
		return stats, err
	}

	for _, currentProcess := range allProcesses {
		name, _ := currentProcess.Name()
		cpuUsage, _ := currentProcess.CPUPercent()
		memory_usage, _ := currentProcess.MemoryPercent()
		username, _ := currentProcess.Username()
		pid := currentProcess.Pid

		process := data.Process{
			Name:        name,
			CPUUsage:    cpuUsage,
			MemoryUsage: float64(memory_usage),
			Pid:         pid,
			Username:    username,
		}

		stats = append(stats, process)

	}
	return stats, nil
}func (m *Monitor) GetSystemProcesses() ([]data.Process, error) {
	stats := []data.Process{}

	allProcesses, err := process.Processes()
	if err != nil {
		return stats, err
	}

	for _, currentProcess := range allProcesses {
		name, _ := currentProcess.Name()
		cpuUsage, _ := currentProcess.CPUPercent()
		memory_usage, _ := currentProcess.MemoryPercent()
		username, _ := currentProcess.Username()
		pid := currentProcess.Pid

		process := data.Process{
			Name:        name,
			CPUUsage:    cpuUsage,
			MemoryUsage: float64(memory_usage),
			Pid:         pid,
			Username:    username,
		}

		stats = append(stats, process)

	}
	return stats, nil
}

Getting filesystems

func (m *Monitor) GetFileSystems() ([]data.DiskStats, error) {
	stats := []data.DiskStats{}

	diskPartitions, err := disk.Partitions(false)
	if err != nil {
		return []data.DiskStats{}, err
	}

	for _, diskPartition := range diskPartitions {
		if !strings.Contains(diskPartition.Device, "loop") {
			diskStats, _ := disk.Usage(diskPartition.Mountpoint)

			stats = append(stats, data.DiskStats{
				Path:           "/",
				DiskType:       diskStats.Fstype,
				Device:         diskPartition.Device,
				Total:          diskStats.Total,
				Free:           diskStats.Free,
				Used:           diskStats.Used,
				UsedPercentage: diskStats.UsedPercent,
			})
		}
	}
	return stats, nil
}

Putting all together using the Go HTTP router

func (s *Server) getStats(w http.ResponseWriter, r *http.Request) {
	resources, err := s.Monitor.GetSystemResources()
	if err != nil {
		http.Error(w, "Failed to System stats", http.StatusInternalServerError)
		return
	}

	processes, err := s.Monitor.GetSystemProcesses()
	if err != nil {
		http.Error(w, "Failed to System stats", http.StatusInternalServerError)
		return
	}

	fileSystems, err := s.Monitor.GetFileSystems()
	if err != nil {
		http.Error(w, "Failed to System stats", http.StatusInternalServerError)
		return
	}

	json, err := json.Marshal(map[string]interface{}{
		"resources":   resources,
		"processes":   processes,
		"filesystems": fileSystems,
	})
	if err != nil {
		http.Error(w, "Failed to System stats", http.StatusInternalServerError)
		return
	}

	w.Write(json)
}

That’s all folks! A very simple Remote System Monitor (ReSysTor).