Esempio n. 1
0
// Report resource.
func (m *Memory) Report() {
	for {
		select {
		case <-time.Tick(m.Interval):
			log.Info("memory: reporting")

			stat, err := linux.ReadMemInfo(m.Path)

			if err != nil {
				log.Error("memory: %s", err)
				continue
			}

			m.client.Gauge("percent", percent(stat))
			m.client.Gauge("swap.percent", swapPercent(stat))

			if m.Extended {
				m.client.Gauge("total", bytes(stat["MemTotal"]))
				m.client.Gauge("used", bytes(used(stat)))
				m.client.Gauge("free", bytes(stat["MemFree"]))
				m.client.Gauge("active", bytes(stat["Active"]))
				m.client.Gauge("swap.total", bytes(stat["SwapTotal"]))
				m.client.Gauge("swap.free", bytes(stat["SwapFree"]))
			}

		case <-m.exit:
			log.Info("mem: exiting")
			return
		}
	}
}
Esempio n. 2
0
func (m *MemoryUsage) Usage() float64 {
	memInfo, _ := linuxproc.ReadMemInfo("/proc/meminfo")

	m.free = memInfo.MemFree + memInfo.Buffers + memInfo.Cached
	m.total = memInfo.MemTotal

	return float64(1 - float64(m.free)/float64(m.total))
}
func (mc memoryChecker) avMemoryCheck() (string, error) {
	meminfo, err := linuxproc.ReadMemInfo(*hostPath + "/proc/meminfo")
	if err != nil {
		return "", err
	}
	available := meminfo.MemAvailable
	total := meminfo.MemTotal
	availablePercent := float64(available) / float64(total) * 100
	if availablePercent < mc.thresholdPercent {
		return fmt.Sprintf("%2.1f%%", availablePercent), fmt.Errorf("Low available memory: %2.1f%%", availablePercent)
	}
	return fmt.Sprintf("%2.1f%%", availablePercent), nil
}
Esempio n. 4
0
File: pc.go Progetto: FloydZ/xengo
//Initalisiert Dynamischen Pc
func (y *PCDynamic) PCInitDynamic(s *SSH) error {
	/*
		Id int						`id`

		MemFree string				`memfree`
		MemAvailable string			`memavail`
		MemUsed uint64				`memused`
		MemUsedProzent float64		`memusedprozent`

		LoadAvg float64				`loadavg`
		NumProcess uint64			`numprocess`
	*/
	loadavg := &linuxproc.LoadAvg{}
	meminfo := &linuxproc.MemInfo{}
	err := errors.New("")

	if s.Client == nil {
		err := errors.New("Could not find a ssh Client ")
		revel.ERROR.Print(err)
		return err
	} else {
		s.Download("/proc/loadavg", tempDir+"/loadavg"+strconv.Itoa(y.Id))
		loadavg, err = linuxproc.ReadLoadAvg("/proc/loadavg")
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}

		y.LoadAvg = loadavg.Last1Min
		y.NumProcess = loadavg.ProcessRunning

		s.Download("/proc/meminfo", tempDir+"/meminfo"+strconv.Itoa(y.Id))
		meminfo, err = linuxproc.ReadMemInfo("/home/pr0gramming/Dokumente/meminfo" + strconv.Itoa(y.Id))
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}

	}

	y.MemUsed = bytefmt.ByteSize((meminfo.MemTotal - meminfo.MemFree) * 1024)
	y.MemFree = bytefmt.ByteSize(meminfo.MemFree * 1024)
	y.MemAvailable = bytefmt.ByteSize(meminfo.MemAvailable * 1024)

	a := float64(meminfo.MemTotal)
	b := float64(meminfo.MemFree)
	y.MemUsedProzent = strconv.FormatFloat(float64(((a-b)/a)*100), 'f', -1, 64)

	//println("test: " + (y.MemUsedProzent))
	return nil
}
func main() {
	uaid := os.Getenv("UAID")

	if uaid == "" {
		panic("UAID environment required. Example: UAID=UA-XXXXXX-Y ./server-analytics")
	}

	client, err := ga.NewClient(uaid)

	if err != nil {
		panic(err)
	}

	ticker := time.NewTicker(15 * time.Second)
	quit := make(chan struct{})
	stop := false

	for !stop {
		select {
		case <-ticker.C:
			diskInfo, err := linuxproc.ReadDisk("/")
			_ = err

			client.Send(ga.NewEvent("Disk", "All").Label("Total Disk Space").Value(int64(diskInfo.All)))
			client.Send(ga.NewEvent("Disk", "Used").Label("Used Disk Space").Value(int64(diskInfo.Used)))
			client.Send(ga.NewEvent("Disk", "Free").Label("Free Disk Space").Value(int64(diskInfo.Free)))

			loadAvg, err := linuxproc.ReadLoadAvg("/proc/loadavg")
			_ = err

			client.Send(ga.NewEvent("Load Average", "1m").Label("1m").Value(int64(loadAvg.Last1Min)))
			client.Send(ga.NewEvent("Load Average", "5m").Label("5m").Value(int64(loadAvg.Last5Min)))
			client.Send(ga.NewEvent("Load Average", "15m").Label("15m").Value(int64(loadAvg.Last15Min)))
			client.Send(ga.NewEvent("Load Average", "Running").Label("Process Running").Value(int64(loadAvg.ProcessRunning)))
			client.Send(ga.NewEvent("Load Average", "Total").Label("Process Total").Value(int64(loadAvg.ProcessTotal)))

			meminfo, err := linuxproc.ReadMemInfo("/proc/meminfo")
			_ = err

			client.Send(ga.NewEvent("Memory", "Total").Label("Memory Total").Value(int64(meminfo.MemTotal)))
			client.Send(ga.NewEvent("Memory", "Free").Label("Memory Free").Value(int64(meminfo.MemFree)))

		case <-quit:
			ticker.Stop()
			return
		}
	}
}
Esempio n. 6
0
File: pc.go Progetto: FloydZ/xengo
//Initalisiert Pc
func (x *PCAll) Pc_Init_All() error {
	cpuinfo, err := linuxproc.ReadCPUInfo("/proc/cpuinfo")
	if err != nil {
		revel.ERROR.Print(err)
		return err
	}
	meminfo, err := linuxproc.ReadMemInfo("/proc/meminfo")
	if err != nil {
		revel.ERROR.Print(err)
		return err
	}
	diskinfo, err := linuxproc.ReadDiskStats("/proc/diskstats")
	if err != nil {
		revel.ERROR.Print(err)
		return err
	}

	netstat, err := linuxproc.ReadNetStat("/proc/net/netstat")
	if err != nil {
		revel.ERROR.Print(err)
		return err
	}

	netdev, err := linuxproc.ReadNetworkStat("/proc/net/dev")
	if err != nil {
		revel.ERROR.Print(err)
		return err
	}

	x.Cpuinfo = cpuinfo
	x.Meminfo = meminfo
	x.Diskstat = diskinfo
	x.Netstat = netstat
	x.Netdev = netdev

	return nil
}
Esempio n. 7
0
	// From http://stackoverflow.com/questions/23367857/accurate-calculation-of-cpu-usage-given-in-percentage-in-linux
	var (
		currentStat = stat.CPUStatAll
		prevIdle    = previousStat.Idle + previousStat.IOWait
		idle        = currentStat.Idle + currentStat.IOWait
		prevNonIdle = (previousStat.User + previousStat.Nice + previousStat.System +
			previousStat.IRQ + previousStat.SoftIRQ + previousStat.Steal)
		nonIdle = (currentStat.User + currentStat.Nice + currentStat.System +
			currentStat.IRQ + currentStat.SoftIRQ + currentStat.Steal)
		prevTotal = prevIdle + prevNonIdle
		total     = idle + nonIdle
		// differentiate: actual value minus the previous one
		totald = total - prevTotal
		idled  = idle - prevIdle
	)
	previousStat = currentStat
	return float64(totald-idled) * 100. / float64(totald), float64(len(stat.CPUStats)) * 100.
}

// GetMemoryUsageBytes returns the bytes memory usage and max
var GetMemoryUsageBytes = func() (float64, float64) {
	meminfo, err := linuxproc.ReadMemInfo(ProcMemInfo)
	if err != nil {
		return 0.0, 0.0
	}

	used := meminfo.MemTotal - meminfo.MemFree - meminfo.Buffers - meminfo.Cached
	return float64(used * kb), float64(meminfo.MemTotal * kb)
}
Esempio n. 8
0
File: pc.go Progetto: FloydZ/xengo
//Initalisiert Statischen Pc
func (y *PCStatic) PCInitStatic(s *SSH) error {
	/*
		NumCPUS	int
		NumVCORES int
		NumVCORESUsed int
		NumPhysicalCores int
		NumVCORESUsedProzent float64

		MemTotal string
		MemUsed string

		NetDevices string
	*/

	cpuinfo := &linuxproc.CPUInfo{}
	meminfo := &linuxproc.MemInfo{}
	netdev := []linuxproc.NetworkStat{}

	err := errors.New("")

	if s.Client == nil {
		err := errors.New("Could not find a ssh Client ")
		revel.ERROR.Print(err)
		return err
	} else {
		s.Download("/proc/cpuinfo", tempDir+"/cpuinfo"+strconv.Itoa(y.Id))
		cpuinfo, err = linuxproc.ReadCPUInfo(tempDir + "/cpuinfo" + strconv.Itoa(y.Id))
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}
		s.Download("/proc/meminfo", tempDir+"/meminfo"+strconv.Itoa(y.Id))
		meminfo, err = linuxproc.ReadMemInfo(tempDir + "/meminfo" + strconv.Itoa(y.Id))
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}
		s.Download("/proc/net/dev", tempDir+"/net"+strconv.Itoa(y.Id))
		netdev, err = linuxproc.ReadNetworkStat(tempDir + "/net" + strconv.Itoa(y.Id))
		if err != nil {
			revel.ERROR.Print(err)
			return err
		}
	}

	y.NumCPUS = cpuinfo.NumCPU()
	y.NumPhysicalCores = cpuinfo.NumPhysicalCPU()
	y.NumVCORES = (cpuinfo.NumCore() + 1) * 2
	y.NumVCORESUsed = y.NumVCORES / 2 //%TODO fake und so

	a := float64(y.NumVCORESUsed)
	b := float64(y.NumVCORES)
	y.NumVCORESUsedProzent = strconv.FormatFloat(float64(a/b)*100, 'f', -1, 64)

	y.NetDevices = netdev[0].Iface

	y.MemTotal = bytefmt.ByteSize(meminfo.MemTotal * 1024)
	y.MemUsed = bytefmt.ByteSize((meminfo.MemTotal - meminfo.MemFree) * 1024)

	return nil
}