writing a system statitistics application in go

whbeebe
Running pistats on a Raspberry Pi 5 and Linux Ubuntu 22.04.2

I have had a need for a simple computer system monitoring tool that would only monitor the system attributes I cared about. I also wanted that monitoring tool to save its measurements to a log file over time, so that I could mine the logs for any trends. I looked at a number of the top utilities (top, atop, btop++, htop) and pretty much marked them off my list, primarily because they measured too much to suite me. I looked at fastfetch and other such tools and dropped them for the same reason, even though you can tailor them with a config file and/or command line switches to only print what I wanted.

I also had a need to bring my Go programming skills back up to some reasonable level of competency and sophistication. I’ve been coding in Go since I first came across it ten years ago, but I never stuck consistently with it. My involvement varied over time. I felt I needed to brush up on the latest version of Go (which as of this writing is at version 1.24.1) and then begin to write software that would motivate me to learn the breadth and depth of the language and all it had to offer. If nothing else I needed a break from my growing frustrations with Rust.

And so I wrote the utility pistat in Go.

Running pistats on a AMD Ryzen 5 and Linux Mint 22.1

The application is simple enough. It gathers the statistics that matter to me, formats them into an easy-to-read format, and then displays them on the terminal as well as writes them to a log file. Along the way I learned how to read and process certain Linux kernel statics as well as write colored text to the terminal (that was interesting) and to navigate my way into creating and using a log file. Every time pistats is run it appends those statistics to its log file in your home directory.

I originally wrote this for my Raspberry Pis, naively thinking that it would be applicable everywhere. Was I ever wrong about that. There are some “cheats” to get it to work with the AMD (Intel) chip-based system I use as my daily driver, specifically for the hardware platform and the core type. I’m not interested in supporting nearly every hardware platform out there, just the two I care about here at home.

I run it inside a terminal window with a single line of fish script: while true; clear && pistats; sleep 60; end. Then I shrink the terminal down to just large enough to hold the text without wrapping, then put it up in the upper right corner of my desktop and go on about my business.

Although the code is in a single nearly 400-line source file, it isn’t monolithic. Each statistic has a subroutine function that’s called to get the statistics. The report is generated in one function, and then separate functions are called to display in the terminal as well as write to the log file. Every function has a comment block explaining what it does, and there is further commenting as needed internal to each function. It may not be pure idiomatic Go code, but I’m a lot more comfortable with Go (again), and that’s a big win for me.

package mainimport ("bufio""errors""fmt""container/list""log""math""net""os""strconv""strings""syscall""time""github.com/logrusorgru/aurora/v4")// osRelease reads the file /etc/os-release and// filters out the PRETTY_NAME of the OS. It also// trims off any spaces and the double quotes around// the pretty OS name.// It returns the result as a string.func osRelease() string {osrelease, error := os.Open("/etc/os-release")if error != nil {log.Fatal(error)}defer osrelease.Close()scanner := bufio.NewScanner(osrelease)var osname = ""for scanner.Scan() {line := scanner.Text()if strings.Contains(line, "PRETTY_NAME=") {osname = strings.Split(line, "=")[1]osname = strings.Trim(osname, " \"")}}return osname}// kernelVersion reads the file /proc/version and// parses out the kernel version. It also trims// off any spaces.// It returns the result as a string.func kernelVersion() string {procversion, error := os.Open("/proc/version")if error != nil {log.Fatal(error)}defer procversion.Close()scanner := bufio.NewScanner(procversion)var version = ""for scanner.Scan() {version = scanner.Text()version = strings.Split(version, " ")[2]version = strings.TrimSpace(version)}return version}// diskUsage reads the full filesystem size and// the free amount of disk space on the filesystem.// It returns the full filesystem size and free filesystem// size as unsigned 64-bit integers.func diskUsage(path string) (uint64, uint64) {fileSystem := syscall.Statfs_t{}error := syscall.Statfs(path, &fileSystem)if error != nil {log.Fatal(error)}all := fileSystem.Blocks * uint64(fileSystem.Bsize)free := fileSystem.Bfree * uint64(fileSystem.Bsize)return all, free}// uptime reads the system up time at /proc/uptime.// It returns the up time as a formated string.// If the uptime is less than 24 hours, it returns just// the uptime in hours.// If the uptime is greater than or equal to 24 hours,// it returns both days and hours.func uptime() string {procUptime, error := os.Open("/proc/uptime")if error != nil {log.Fatal(error)}defer procUptime.Close()scanner := bufio.NewScanner(procUptime)var line = ""for scanner.Scan() {line = scanner.Text()}var secondsUptimeStr = strings.Split(line, " ")[0]secondsUptimeStr = strings.TrimSpace(secondsUptimeStr)var secondsUptime, _ = strconv.ParseFloat(secondsUptimeStr, 32)const SECONDS_IN_A_DAY float64 = 86400.0const SECONDS_IN_AN_HOUR float64 = 3600.0var daysUptime = math.Floor(secondsUptime / SECONDS_IN_A_DAY)secondsUptime -= daysUptime * SECONDS_IN_A_DAYvar hoursUptime = math.Round(secondsUptime / SECONDS_IN_AN_HOUR)if daysUptime > 0.0 {if daysUptime == 1.0 {return fmt.Sprintf("1 day, %.0f hours", hoursUptime)} else {return fmt.Sprintf("%.0f days, %.0f hours",daysUptime, hoursUptime)}} else {return fmt.Sprintf("%.0f hours", hoursUptime)}}// translateMeminfo translates the string parsed from a meminfo// value to an unsigned 64-bit integer.// Because the values in meminfo are already divided by 1024, or 1KiB,// the value returned is in thousands of bytes, not single bytes.func translateMeminfo(line string) uint64 {var meminfoValue = strings.Split(line, ":")[1]meminfoValue = strings.TrimSpace(meminfoValue)var memoryValue = strings.Split(meminfoValue, " ")[0]memoryValue = strings.TrimSpace(memoryValue)var value, _ = strconv.ParseUint(memoryValue, 10, 64)return value}// memInfo parses out MemTotal, MemAvailable, SwapTotal, and SwapFree// from /proc/meminfo.// Because the values in meminfo are already divided by 1024, or 1KiB,// the values returned are in thousands of bytes, not single bytes.func memInfo() (uint64, uint64, uint64, uint64) {meminfo, error := os.Open("/proc/meminfo")if error != nil {log.Fatal(error)}defer meminfo.Close()scanner := bufio.NewScanner(meminfo)var memoryTotal uint64 = 0var memoryFree uint64 = 0var swapTotal uint64 = 0var swapFree uint64 = 0for scanner.Scan() {line := scanner.Text()if strings.Contains(line, "MemTotal:") {memoryTotal = translateMeminfo(line)}if strings.Contains(line, "MemAvailable:") {memoryFree = translateMeminfo(line)}if strings.Contains(line, "SwapTotal:") {swapTotal = translateMeminfo(line)}if strings.Contains(line, "SwapFree:") {swapFree = translateMeminfo(line)}}return memoryTotal, memoryFree, swapTotal, swapFree}// decodeCorePartNumber decodes the CPU part number found in /proc/cpuinfo// and converts it into the human readable ARM core name.// Note this only works with a Raspberry Pi or equivalent.func decodeCorePartNumber(line string) string {var partNumber = strings.Split(line, ":")[1]partNumber = strings.TrimSpace(partNumber)partNumber = strings.ToUpper(partNumber)switch partNumber {case "0XD01":return "Cortex-A32"case "0XD02":return "Cortex-A34"case "0XD03":return "Cortex-A53"case "0XD04":return "Cortex-A35"case "0XD05":return "Cortex-A55"case "0XD06":return "Cortex-A65"case "0XD07":return "Cortex-A57"case "0XD08":return "Cortex-A72"case "0XD09":return "Cortex-A73"case "0XD0A":return "Cortex-A75"case "0XD0B":return "Cortex-A76"case "0XD0D":return "Cortex-A77"case "0XD0E":return "Cortex-A76AE"default:return "NO MATCH"}}// cpuInfo finds the hardware platform name, core type, and core count// from /proc/cpuinfo.//// The kernel file path /sys/devices/virtual/dmi/id/... is tested to see if// it exists, and if it does, then set the hardware platform name to// the string contents of /sys/devices/virtual/dmi/id/product_name.//// This is a personal test for running this application on an AMD-based// MinisForum tiny computer I own.// Return values are the hardware platform name as a string,// the core type as a string, and core count as an integer.func cpuInfo() (string, string, int) {var platform = ""productname, error :=os.ReadFile("/sys/devices/virtual/dmi/id/product_name")if !errors.Is(error, os.ErrNotExist) {platform = strings.TrimSpace(string(productname))}var coreType = ""var coreCount = 0cpuinfo, error := os.Open("/proc/cpuinfo")if error != nil {log.Fatal(error)}defer cpuinfo.Close()scanner := bufio.NewScanner(cpuinfo)for scanner.Scan() {line := scanner.Text()if strings.Contains(line, "Model") && len(platform) == 0 {platform = strings.Split(line, ":")[1]platform = strings.TrimSpace(platform)}if strings.Contains(line, "model name") && len(coreType) == 0 {coreType = strings.Split(line, ":")[1]coreType = strings.Split(coreType,"w/")[0]coreType = strings.TrimSpace(coreType)}if strings.Contains(line, "CPU part") && len(coreType) == 0 {coreType = decodeCorePartNumber(line)}if strings.Contains(line, "processor") {coreCount++}}if error := scanner.Err(); error != nil {log.Fatal(error)}return platform, coreType, coreCount}// hostIP4 returns the host's IP4 dotted address as a string.func hostIP4() string {connection, error := net.Dial("udp", "8.8.8.8:80")if error != nil {log.Fatal(error)}defer connection.Close()address := connection.LocalAddr().(*net.UDPAddr).String()// The address is a UDP address with a port on the end.// Trim that off along with the ':' character.return strings.Split(address,":")[0]}// generateReport generates a list of all the information we wish to// capture in text format.// Returns a list of text strings.func generateReport() *list.List {currentTime := time.Now()formattedTime := currentTime.Format(time.RFC1123)var hostname, error = os.Hostname()if error != nil {hostname = "UNKNOWN"}var platform, cType, cCount = cpuInfo()var memoryTotalK, memoryFreeK, swapTotalK, swapFreeK = memInfo()const GiBK float64 = 1024.0 * 1024.0var diskTotal, diskFree = diskUsage("/")const GiB float64 = 1024.0 * 1024.0 * 1024.0var rep = list.New()rep.PushBack(fmt.Sprintf("%+22s= %s\n", "Current time", formattedTime))rep.PushBack(fmt.Sprintf("%+22s= %s\n", "Host name", hostname))rep.PushBack(fmt.Sprintf("%+22s= %s\n", "Hardware platform", platform))rep.PushBack(fmt.Sprintf("%+22s= %s / %d\n", "Core type / count", cType, cCount))rep.PushBack(fmt.Sprintf("%+22s= %s\n", "Operating system", osRelease()))rep.PushBack(fmt.Sprintf("%+22s= %s\n", "Kernel version", kernelVersion()))rep.PushBack(fmt.Sprintf("%+22s= %.1f GiB / %.1f GiB\n","Memory total / free",float64(memoryTotalK)/GiBK, float64(memoryFreeK)/GiBK))rep.PushBack(fmt.Sprintf("%+22s= %.1f GiB / %.1f GiB\n","Swap total / free",float64(swapTotalK)/GiBK, float64(swapFreeK)/GiBK))rep.PushBack(fmt.Sprintf("%+22s= %.2f GiB\n","Filesystem capacity", float64(diskTotal)/GiB))rep.PushBack(fmt.Sprintf("%+22s= %.2f GiB\n","Filesystem available", float64(diskFree)/GiB))rep.PushBack(fmt.Sprintf("%+22s= %s\n", "Uptime", uptime()))rep.PushBack(fmt.Sprintf("%+22s= %s\n", "IP Address", hostIP4()))return rep}// displayReport takes a list of strings representing the report generated by// generateReport and reformats them into a format suitable for the terminal// screen, including the incorporation of color.func displayReport(report *list.List) {for line := report.Front(); line != nil; line = line.Next() {if str, ok := line.Value.(string); ok {parts := strings.Split(str, "=")fmt.Printf("%s%s", aurora.Red(parts[0]+":").Bold(), parts[1])}}}// logReport takes a list of strings representing the report generated by// generate report and appends them, unmodified and in the order create by// generateReport, at the end of the log file located in// $HOME/.local/share/pistats/pistats.logfunc logReport(report *list.List) {// We want to know our home directory so we can log our report.// Abort the application if we can't get our home directory.// If we can't get our home directory, then we've got Very Big Problems.userHomeDir, err0 := os.UserHomeDir()if err0 != nil {log.Fatal(err0)}// Check to see if we can create a log file for this application by checking// for $HOME/.local/share/pistat at a minimum. If there is a problem then// silently fail and return.logpath := userHomeDir + "/.local/share/pistat/"_, err1 := os.Stat(logpath)if err1 != nil && os.IsNotExist(err1) {if err2 := os.MkdirAll(logpath, 0770); err2 != nil {return}}// Now try to open the log file. The first time this application is run it// will not exist. If we fail to open the log file, then silently fail and// return.fullpath := logpath + "pistats.log"logfile, err3 :=os.OpenFile(fullpath, os.O_APPEND | os.O_WRONLY | os.O_CREATE, 0644)if err3 != nil {return}defer logfile.Close()// The full log file and path exist and it's open. Append the current report// to the log file. Write a blank line to the end to separate reports.for line := report.Front(); line != nil; line = line.Next() {//fmt.Print(line.Value)logfile.WriteString(line.Value.(string))}logfile.WriteString("\n")}func main() {report := generateReport()displayReport(report)logReport(report)}

what is wrong with apple?

whbeebe2 Comments

This is a story about the old vs the new. In my case, it was about an Amazon Echo Dot generation 2 vs an iPhone 16 Pro Max. Let me explain…

I’ve been going around and cleaning out old items around my home, especially unmarked boxes that for whatever reason got stuffed into various corners, where they remained for many a year. When I say many, I’m talking about going back to when I was still fully employed. One day while going through one of those mystery boxes I found an Amazon Echo Dot generation 2 unopened in its box. I have no idea when I purchased it, although it had to be after October 2016 when this model was released. I do have an idea how it was placed into the box I found it in. Back then I was traveling a bit and and was very busy in my job, so we reached out to a cleaning company to get someone into our house to help my wife keep the place clean. One of the cleaning people had a bad habit of “temporarily” placing items into boxes in order to clear an area to clean. That cleaning person had a very bad habit of not telling us she’d done that, and it was but one reason she was eventually sent on her way. I thought I’d found everything she’d stashed away, but I was wrong with this particular item in that box.

We already have a number of Alexa/Amazon items in the house, although we barely use them except to play the occasional tune or to verbally ask Alexa to turn off the lights in one room of our house. We have three advanced models that can display the time, so I have those scattered around as heavily over-engineered digital clocks (and we’ll occasionally set a wakeup alarm with them). I decided to plug in this old/new stock Echo Dot and get it integrated our home network. That’s when my problems stated.

I have the latest Alexa app installed on my iPhone, and have had it on all my iPhones going back at least to Christmas 2016, which is when I believe I purchased this one. I use the Alexa app to bring these Echo devices up and integrated into our home network. Usually when I get a new Echo Dot it gets almost immediately powered on and set up, but apparently not this time. Now I was faced with using the latest iPhone with the latest Alexa app trying to integrate an Echo Dot from late 2016, nearly nine long years ago. A lot of technical advancement happens in a nine year period. And that might have been my problem.

With Alexa up and running on my iPhone and this Echo Dot up and waiting for integration, I found I couldn’t add it to my Alexa network using my iPhone 16, no matter how many times I tried. The iPhone with Alexa would not detect this Echo Dot. I wasted a week of evenings trying one solution after another, discovering yet again during this process that the Internet is full of useless advice. I gave up with the iPhone and was seriously considering tearing the Echo Dot open just to see if I could repurpose the electronics.

And then I reached into my collection of old Pixel Android phones and pulled out a Pixel 4a. I purchased a Pixel 2, a Pixel 3x, and two Pixel 4as back in 2020 for a project because they’d been heavily discounted by Amazon of all places. I’m talking half price or less. I picked the 4a because I like its small compact design. It was running Android 13, which is where Google stopped updating the device (which I can thank my luck stars). I could still install from Google Play so I installed the same version of Alexa on the Pixel 4a as I had on my iPhone 16. I then sat down and tried to bring the Echo Dot up using that Pixel 4a. Low and behold it worked the first time. That Echo Dot is now fully integrated in with the rest of my Amazon Echo devices.

So here’s the question. How is that that an “obsolete” Pixel 4a running Android 13 but the same version of Alexa that my latest and greatest iPhone 16 Pro Max, running the latest and greatest iOS version, and with the same version of Alexa as found on Google Play, can properly communicate with the Echo Dot generation 2 when my iPhone 16 can’t?

I have never regretted an Apple device purchase until now. I still wish I had my old iPhone 11 Pro Max, and I would still have it except the 11’s mobile radio was beginning to fail with dropped calls and an inability to be cleared unless the handset was power cycled. I couldn’t have that. The 16’s mobile radio is reliable (so far), so I should be thankful for that. But there have been enough aggravating quirks while operating the 16 that I wish I could trade it in for something completely different. But then I read the horror stories of Android handset problems, especially after an Android software update, and I just have to shake my head. I think it’s all been enshitified now. I need to start looking for much older Pixel handsets, such as perhaps the Pixel 5, or maybe the Pixel 6. Something old but reliable, like the 4as.

Today’s handsets and mobile operating systems are a classic Hobson’s choice.