Direct OS metrics needs to accommodate OS deficiencies

[JBHighHair]

There is a potential issue where metric collection for psutil_mem and psutil_cpu results in NaNs
In the case of psutil_mem, no metics are recorded at all (the public.psutil_mem table is empty)

When looking at /internal/reaper/psutil.go I can see potential issues where it would be possible to divide by zero simply because it does not cater for OS.

func GetGoPsutilMem

When vm.SwapTotal is 0 (occurs when OS is Windows) there is a divide by zero which results in NaN.
I've tested GetGoPsutilMem in my environment and it returns NaN for swap_percent...

Below is the updated code which mitigates this issue...

func GetGoPsutilMem() (metrics.Measurements, error) {
	vm, err := mem.VirtualMemory()
	if err != nil {
		return nil, err
	}

	retMap := metrics.NewMeasurement(time.Now().UnixNano())
	retMap["total"] = int64(vm.Total)
	retMap["used"] = int64(vm.Used)
	retMap["free"] = int64(vm.Free)
	retMap["buff_cache"] = int64(vm.Buffers)
	retMap["available"] = int64(vm.Available)
	retMap["percent"] = math.Round(100*vm.UsedPercent) / 100
	retMap["swap_total"] = int64(vm.SwapTotal)
	retMap["swap_used"] = int64(vm.SwapCached)
	retMap["swap_free"] = int64(vm.SwapFree)
	if vm.SwapTotal == 0 {
		retMap["swap_percent"] = 0
	} else {
		retMap["swap_percent"] = math.Round(100*float64(vm.SwapCached)/float64(vm.SwapTotal)) / 100
	}

	return metrics.Measurements{retMap}, nil
}

func GetGoPsutilCPU

When totalDiff is 0 there is a divide by zero which results in NaN.
Below is the updated code which mitigates this issue...

// GetGoPsutilCPU simulates "psutil" metric output. Assumes the result from last call as input
func GetGoPsutilCPU(interval time.Duration) (metrics.Measurements, error) {
	prevCPULoadTimeStatsLock.RLock()
	prevTime := prevCPULoadTimestamp
	prevTimeStat := prevCPULoadTimeStats
	prevCPULoadTimeStatsLock.RUnlock()

	curCallStats, err := cpu.Times(false)
	if err != nil {
		return nil, err
	}
	if time.Since(prevTime) >= interval {
		prevCPULoadTimeStatsLock.Lock() // update the cache
		prevCPULoadTimeStats = curCallStats[0]
		prevCPULoadTimestamp = time.Now()
		prevCPULoadTimeStatsLock.Unlock()
	}

	la, err := load.Avg()
	if err != nil {
		return nil, err
	}

	cpus, err := cpu.Counts(true)
	if err != nil {
		return nil, err
	}

	retMap := metrics.NewMeasurement(time.Now().UnixNano())
	retMap["cpu_utilization"] = math.Round(100*goPsutilCalcCPUUtilization(prevTimeStat, curCallStats[0])) / 100
	retMap["load_1m_norm"] = math.Round(100*la.Load1/float64(cpus)) / 100
	retMap["load_1m"] = math.Round(100*la.Load1) / 100
	retMap["load_5m_norm"] = math.Round(100*la.Load5/float64(cpus)) / 100
	retMap["load_5m"] = math.Round(100*la.Load5) / 100
	totalDiff := cpuTotal(curCallStats[0]) - cpuTotal(prevTimeStat)
	if totalDiff == 0 {
		retMap["user"] = 0	
		retMap["system"] = 0	
		retMap["idle"] = 0
		retMap["iowait"] = 0	
		retMap["irqs"] = 0
		retMap["other"] = 0	
	} else {
		retMap["user"] = math.Round(10000.0*(curCallStats[0].User-prevTimeStat.User)/totalDiff) / 100
		retMap["system"] = math.Round(10000.0*(curCallStats[0].System-prevTimeStat.System)/totalDiff) / 100
		retMap["idle"] = math.Round(10000.0*(curCallStats[0].Idle-prevTimeStat.Idle)/totalDiff) / 100
		retMap["iowait"] = math.Round(10000.0*(curCallStats[0].Iowait-prevTimeStat.Iowait)/totalDiff) / 100
		retMap["irqs"] = math.Round(10000.0*(curCallStats[0].Irq-prevTimeStat.Irq+curCallStats[0].Softirq-prevTimeStat.Softirq)/totalDiff) / 100
		retMap["other"] = math.Round(10000.0*(curCallStats[0].Steal-prevTimeStat.Steal+curCallStats[0].Guest-prevTimeStat.Guest+curCallStats[0].GuestNice-prevTimeStat.GuestNice)/totalDiff) / 100
	}

PL/Python wrappers are not an option

I'm running pgwatch on clusters and returning the collected metrics to a sink.
Unfortunately, since direct-os-stats flag is deprecated and hard set to True, I cannot use SQL queries via PL/Python wrappers which I customised to handle different OS provided below...

            CREATE OR REPLACE FUNCTION get_psutil_mem(
            	OUT total float8, OUT used float8, OUT free float8, OUT buff_cache float8, OUT available float8, OUT percent float8,
            	OUT swap_total float8, OUT swap_used float8, OUT swap_free float8, OUT swap_percent float8
            )
             LANGUAGE plpython3u
            AS $FUNCTION$

            import platform
            from psutil import virtual_memory, swap_memory
            vm = virtual_memory()
            sw = swap_memory()
            # buffers and cached only apply to Linux
            if platform.system() == "Windows":
                buff_cache = 0
                return vm.total, vm.used, vm.free, buff_cache, vm.available, vm.percent, sw.total, sw.used, sw.free, sw.percent
            elif platform.system() == "Linux":
                return vm.total, vm.used, vm.free, vm.buffers + vm.cached, vm.available, vm.percent, sw.total, sw.used, sw.free, sw.percent
            $FUNCTION$;

            CREATE OR REPLACE FUNCTION get_psutil_cpu(
            	OUT cpu_utilization float8, OUT load_1m_norm float8, OUT load_1m float8, OUT load_5m_norm float8, OUT load_5m float8,
                OUT "user" float8, OUT system float8, OUT idle float8, OUT iowait float8, OUT irqs float8, OUT other float8
            )
             LANGUAGE plpython3u
            AS $FUNCTION$

            import platform
            # getloadavg now part of psutil
            from psutil import cpu_times_percent, cpu_percent, cpu_count, getloadavg
            from threading import Thread

            class GetCpuPercentThread(Thread):
                def __init__(self, interval_seconds):
                    self.interval_seconds = interval_seconds
                    self.cpu_utilization_info = None
                    super(GetCpuPercentThread, self).__init__()

                def run(self):
                    self.cpu_utilization_info = cpu_percent(self.interval_seconds)

            t = GetCpuPercentThread(0.5)
            t.start()

            ct = cpu_times_percent(0.5)
            la = getloadavg()

            t.join()

            # No iowait etc in Windows - Linux only
            if platform.system() == "Windows":
                iowait = 0.0
                irqs = 0.0
                other = 0.0
                return t.cpu_utilization_info, la[0] / cpu_count(), la[0], la[1] / cpu_count(), la[1], ct.user, ct.system, ct.idle, iowait, irqs, other
                # return 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
            elif platform.system() == "Linux":
                return t.cpu_utilization_info, la[0] / cpu_count(), la[0], la[1] / cpu_count(), la[1], ct.user, ct.system, ct.idle, ct.iowait, ct.irq + ct.softirq, ct.steal + ct.guest + ct.guest_nice

            $FUNCTION$;

[pashagolub]

It's fixed by #1418. Have you checked that? It's not released however.

[JBHighHair]

I'm having difficultly compiling for Windows.
I'll wait until the next release. Thanks.

[pashagolub]

what exactly problems do you have? Code base is constantly compiled under windows