perfmonger 0.10.1 → 0.12.0

data/core/subsystem/perfmonger_linux_test.go

@@ -1,6 +1,7 @@
 package subsystem
 
 import (
+	"log"
 	"os"
 	"testing"
 )
@@ -71,3 +72,42 @@ func TestReadNetStat(t *testing.T) {
 		t.Error("Device 'lo' not found.")
 	}
 }
+
+func TestReadMemStat(t *testing.T) {
+	var err error
+	var stat_record *StatRecord = nil
+
+	err = ReadMemStat(stat_record)
+	if err == nil {
+		t.Errorf("Error should not be returned with non-nil *StatRecord.")
+	}
+
+	_, err = os.Stat("/proc/meminfo")
+	if err != nil {
+		t.Skip("/proc/meminfo is not present.")
+	}
+
+	stat_record = NewStatRecord()
+	err = ReadMemStat(stat_record)
+	if err != nil {
+		log.Print(err)
+		t.Error("Error should not be returned with valid *StatRecord.")
+		return
+	}
+	if stat_record.Mem == nil {
+		t.Error("stat_record.Mem should not be nil")
+		return
+	}
+
+	if stat_record.Mem.MemTotal == 0 {
+		t.Error("Cannot read MemTotal correctly")
+		return
+	}
+
+	mem := stat_record.Mem
+
+	if (mem.MemFree + mem.Cached + mem.Buffers) > mem.MemTotal {
+		t.Error("Inconsistent meminfo values")
+		return
+	}
+}

data/core/subsystem/stat.go

@@ -102,6 +102,38 @@ type NetStat struct {
 	Entries []*NetStatEntry
 }
 
+// all values are recorded in KB
+type MemStat struct {
+	MemTotal        int64
+	MemFree         int64
+	Buffers         int64
+	Cached          int64
+	SwapCached      int64
+	Active          int64
+	Inactive        int64
+	SwapTotal       int64
+	SwapFree        int64
+	Dirty           int64
+	Writeback       int64
+	AnonPages       int64
+	Mapped          int64
+	Shmem           int64
+	Slab            int64
+	SReclaimable    int64
+	SUnreclaim      int64
+	KernelStack     int64
+	PageTables      int64
+	NFS_Unstable    int64
+	Bounce          int64
+	CommitLimit     int64
+	Committed_AS    int64
+	AnonHugePages   int64
+	HugePages_Total int64
+	HugePages_Free  int64
+	HugePages_Rsvd  int64
+	HugePages_Surp  int64
+}
+
 type StatRecord struct {
 	Time      time.Time
 	Cpu       *CpuStat
@@ -110,6 +142,7 @@ type StatRecord struct {
 	Disk      *DiskStat
 	Softirq   *SoftIrqStat
 	Net       *NetStat
+	Mem       *MemStat
 }
 
 func (core_stat *CpuCoreStat) Clear() {
@@ -219,6 +252,42 @@ func NewNetStat() *NetStat {
 	return new(NetStat)
 }
 
+func NewMemStat() *MemStat {
+	return new(MemStat)
+}
+
+func (entry *MemStat) Clear() {
+	entry.MemTotal = 0
+	entry.MemFree = 0
+	entry.Buffers = 0
+	entry.Cached = 0
+	entry.SwapCached = 0
+	entry.Active = 0
+	entry.Inactive = 0
+	entry.SwapTotal = 0
+	entry.SwapFree = 0
+	entry.Dirty = 0
+	entry.Writeback = 0
+	entry.AnonPages = 0
+	entry.Mapped = 0
+	entry.Shmem = 0
+	entry.Slab = 0
+	entry.SReclaimable = 0
+	entry.NFS_Unstable = 0
+	entry.SUnreclaim = 0
+	entry.KernelStack = 0
+	entry.PageTables = 0
+	entry.NFS_Unstable = 0
+	entry.Bounce = 0
+	entry.CommitLimit = 0
+	entry.Committed_AS = 0
+	entry.AnonHugePages = 0
+	entry.HugePages_Total = 0
+	entry.HugePages_Free = 0
+	entry.HugePages_Rsvd = 0
+	entry.HugePages_Surp = 0
+}
+
 func NewStatRecord() *StatRecord {
 	return &StatRecord{
 		time.Now(),
@@ -228,6 +297,7 @@ func NewStatRecord() *StatRecord {
 		nil,
 		nil,
 		nil,
+		nil,
 	}
 }
 

data/core/subsystem/stat_test.go

@@ -262,6 +262,14 @@ func TestNewNetStat(t *testing.T) {
 	}
 }
 
+func TestNewMemStat(t *testing.T) {
+	memstat := NewMemStat()
+
+	if memstat == nil {
+		t.Error("failed to create MemStat")
+	}
+}
+
 func TestNewStatRecord(t *testing.T) {
 	stat_record := NewStatRecord()
 
@@ -278,4 +286,5 @@ func TestNewStatRecord(t *testing.T) {
 	checkFieldIsNil("Disk")
 	checkFieldIsNil("Softirq")
 	checkFieldIsNil("Net")
+	checkFieldIsNil("Mem")
 }

data/core/subsystem/usage.go

@@ -2,12 +2,13 @@ package subsystem
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"regexp"
 	"sort"
 	"time"
+
+	projson "github.com/hayamiz/go-projson"
 )
 
 type CpuCoreUsage struct {
@@ -84,25 +85,56 @@ type NetUsageEntry struct {
 
 type NetUsage map[string]*NetUsageEntry
 
-func (ccusage *CpuCoreUsage) WriteJsonTo(buf *bytes.Buffer) {
-	buf.WriteString(
-		fmt.Sprintf(`{"usr":%.2f,"nice":%.2f,"sys":%.2f,"idle":%.2f,"iowait":%.2f,"hardirq":%.2f,"softirq":%.2f,"steal":%.2f,"guest":%.2f,"guestnice":%.2f}`,
-			ccusage.User, ccusage.Nice, ccusage.Sys, ccusage.Idle, ccusage.Iowait,
-			ccusage.Hardirq, ccusage.Softirq, ccusage.Steal, ccusage.Guest, ccusage.GuestNice))
+type MemUsage struct {
+	mem *MemStat
 }
 
-func (cusage *CpuUsage) WriteJsonTo(buf *bytes.Buffer) {
-	buf.WriteString(
-		fmt.Sprintf(`{"num_core":%d,"all":`, cusage.NumCore))
-	cusage.All.WriteJsonTo(buf)
-	buf.WriteString(`,"cores":[`)
-	for idx, ccusage := range cusage.CoreUsages {
-		if idx > 0 {
-			buf.WriteString(",")
-		}
-		ccusage.WriteJsonTo(buf)
+var UseColor = false
+
+func SetUseColor(use_color bool) {
+	UseColor = use_color
+}
+
+func (ccusage *CpuCoreUsage) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+	printer.PutKey("usr")
+	printer.PutFloatFmt(ccusage.User, "%.2f")
+	printer.PutKey("nice")
+	printer.PutFloatFmt(ccusage.Nice, "%.2f")
+	printer.PutKey("sys")
+	printer.PutFloatFmt(ccusage.Sys, "%.2f")
+	printer.PutKey("idle")
+	printer.PutFloatFmt(ccusage.Idle, "%.2f")
+	printer.PutKey("iowait")
+	printer.PutFloatFmt(ccusage.Iowait, "%.2f")
+	printer.PutKey("hardirq")
+	printer.PutFloatFmt(ccusage.Hardirq, "%.2f")
+	printer.PutKey("softirq")
+	printer.PutFloatFmt(ccusage.Softirq, "%.2f")
+	printer.PutKey("steal")
+	printer.PutFloatFmt(ccusage.Steal, "%.2f")
+	printer.PutKey("guest")
+	printer.PutFloatFmt(ccusage.Guest, "%.2f")
+	printer.PutKey("guestnice")
+	printer.PutFloatFmt(ccusage.GuestNice, "%.2f")
+	printer.FinishObject()
+}
+
+func (cusage *CpuUsage) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+	printer.PutKey("num_core")
+	printer.PutInt(cusage.NumCore)
+	printer.PutKey("all")
+
+	cusage.All.WriteJsonTo(printer)
+
+	printer.PutKey("cores")
+	printer.BeginArray()
+	for _, ccusage := range cusage.CoreUsages {
+		ccusage.WriteJsonTo(printer)
 	}
-	buf.WriteString(`]}`)
+	printer.FinishArray()
+	printer.FinishObject()
 }
 
 func GetCpuCoreUsage(c1 *CpuCoreStat, c2 *CpuCoreStat) (*CpuCoreUsage, error) {
@@ -225,35 +257,68 @@ func GetInterruptUsage(t1 time.Time, i1 *InterruptStat, t2 time.Time, i2 *Interr
 	return usage, nil
 }
 
-func (intr_usage *InterruptUsage) WriteJsonTo(buf *bytes.Buffer) {
-	buf.WriteString("{")
-	buf.WriteString(`"core_dev_intr":[`)
-	for idx, core_usage := range intr_usage.CoreIntrUsages {
-		if idx > 0 {
-			buf.WriteString(",")
-		}
-		fmt.Fprintf(buf, "%.2f", core_usage.Device)
+func (intr_usage *InterruptUsage) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+	printer.PutKey("core_dev_intr")
+	printer.BeginArray()
+	for _, core_usage := range intr_usage.CoreIntrUsages {
+		printer.PutFloatFmt(core_usage.Device, "%.2f")
 	}
-	buf.WriteString(`],"core_sys_intr":[`)
-	for idx, core_usage := range intr_usage.CoreIntrUsages {
-		if idx > 0 {
-			buf.WriteString(",")
-		}
-		fmt.Fprintf(buf, "%.2f", core_usage.System)
+	printer.FinishArray()
+
+	printer.PutKey("core_sys_intr")
+	printer.BeginArray()
+	for _, core_usage := range intr_usage.CoreIntrUsages {
+		printer.PutFloatFmt(core_usage.System, "%.2f")
 	}
-	buf.WriteString("]")
-	buf.WriteString("}")
+	printer.FinishArray()
+	printer.FinishObject()
 }
 
-func (duentry *DiskUsageEntry) WriteJsonTo(buf *bytes.Buffer) {
-	fmt.Fprintf(buf,
-		`{"riops":%.2f,"wiops":%.2f,"rkbyteps":%.2f,"wkbyteps":%.2f,"rlatency":%.3f,"wlatency":%.3f,"rsize":%.2f,"wsize":%.2f,"qlen":%.2f}`,
-		duentry.RdIops, duentry.WrIops, duentry.RdSecps/2.0, duentry.WrSecps/2.0,
-		duentry.RdLatency, duentry.WrLatency,
-		duentry.AvgRdSize, duentry.AvgWrSize, duentry.ReqQlen)
+func (duentry *DiskUsageEntry) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+	printer.PutKey("riops")
+	printer.PutFloatFmt(duentry.RdIops, "%.2f")
+	printer.PutKey("wiops")
+	printer.PutFloatFmt(duentry.WrIops, "%.2f")
+	printer.PutKey("rkbyteps")
+	printer.PutFloatFmt(duentry.RdSecps/2.0, "%.2f")
+	printer.PutKey("wkbyteps")
+	printer.PutFloatFmt(duentry.WrSecps/2.0, "%.2f")
+	printer.PutKey("rlatency")
+	printer.PutFloatFmt(duentry.RdLatency, "%.3f")
+	printer.PutKey("wlatency")
+	printer.PutFloatFmt(duentry.WrLatency, "%.3f")
+	printer.PutKey("rsize")
+	printer.PutFloatFmt(duentry.AvgRdSize, "%.2f")
+	printer.PutKey("wsize")
+	printer.PutFloatFmt(duentry.AvgWrSize, "%.2f")
+	printer.PutKey("qlen")
+	printer.PutFloatFmt(duentry.ReqQlen, "%.2f")
+	printer.FinishObject()
 }
 
-func (dusage *DiskUsage) WriteJsonTo(buf *bytes.Buffer) {
+func strarrayToString(arr []string) string {
+	buf := bytes.NewBuffer([]byte{})
+
+	fmt.Fprintf(buf, "[")
+	for i, elem := range arr {
+		if i > 0 {
+			fmt.Fprintf(buf, ",")
+		}
+
+		if UseColor {
+			fmt.Fprintf(buf, "\033[35m\"%s\"\033[0m", elem)
+		} else {
+			fmt.Fprintf(buf, "\"%s\"", elem)
+		}
+	}
+	fmt.Fprintf(buf, "]")
+
+	return buf.String()
+}
+
+func (dusage *DiskUsage) WriteJsonTo(printer *projson.JsonPrinter) {
 	var devices []string
 
 	for device, _ := range *dusage {
@@ -263,23 +328,24 @@ func (dusage *DiskUsage) WriteJsonTo(buf *bytes.Buffer) {
 	}
 	sort.Strings(devices)
 
-	bytes, err := json.Marshal(devices)
-	if err != nil {
-		panic(err)
+	printer.BeginObject()
+	printer.PutKey("devices")
+	printer.BeginArray()
+	for _, device := range devices {
+		printer.PutString(device)
 	}
-	fmt.Fprintf(buf, `{"devices":%s`, string(bytes))
+	printer.FinishArray()
 
 	devices = append(devices, "total")
 
 	for _, device := range devices {
 		usage := (*dusage)[device]
-		buf.WriteString(`,"`)
-		buf.WriteString(device)
-		buf.WriteString(`":`)
-		usage.WriteJsonTo(buf)
+
+		printer.PutKey(device)
+		usage.WriteJsonTo(printer)
 	}
 
-	buf.WriteByte('}')
+	printer.FinishObject()
 }
 
 func avgDelta(v int64, w int64, interval float64) float64 {
@@ -470,7 +536,7 @@ func GetNetUsage(t1 time.Time, d1 *NetStat, t2 time.Time, d2 *NetStat) (*NetUsag
 	return net_usage, nil
 }
 
-func (nusage *NetUsage) WriteJsonTo(buf *bytes.Buffer) {
+func (nusage *NetUsage) WriteJsonTo(printer *projson.JsonPrinter) {
 	var devices []string
 
 	for device, _ := range *nusage {
@@ -480,30 +546,121 @@ func (nusage *NetUsage) WriteJsonTo(buf *bytes.Buffer) {
 	}
 	sort.Strings(devices)
 
-	bytes, err := json.Marshal(devices)
-	if err != nil {
-		panic(err)
+	printer.BeginObject()
+	printer.PutKey("devices")
+	printer.BeginArray()
+	for _, device := range devices {
+		printer.PutString(device)
 	}
-	fmt.Fprintf(buf, `{"devices":%s`, string(bytes))
+	printer.FinishArray()
 
 	devices = append(devices, "total")
 
 	for _, device := range devices {
 		usage := (*nusage)[device]
-		buf.WriteString(`,"`)
-		buf.WriteString(device)
-		buf.WriteString(`":`)
-		usage.WriteJsonTo(buf)
+
+		printer.PutKey(device)
+		usage.WriteJsonTo(printer)
+	}
+
+	printer.FinishObject()
+}
+
+func GetMemUsage(mem *MemStat) (*MemUsage, error) {
+	if mem == nil {
+		return nil, errors.New("invalid memstat")
 	}
 
-	buf.WriteByte('}')
+	musage := new(MemUsage)
+	musage.mem = mem
+
+	return musage, nil
+}
+
+func (musage *MemUsage) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+
+	printer.PutKey("mem_total")
+	printer.PutInt64(musage.mem.MemTotal)
+	printer.PutKey("mem_used")
+	printer.PutInt64(musage.mem.MemTotal - musage.mem.MemFree - musage.mem.Buffers - musage.mem.Cached - musage.mem.SReclaimable)
+	printer.PutKey("mem_free")
+	printer.PutInt64(musage.mem.MemFree)
+	printer.PutKey("buffers")
+	printer.PutInt64(musage.mem.Buffers)
+	printer.PutKey("cached")
+	printer.PutInt64(musage.mem.Cached)
+	printer.PutKey("swap_cached")
+	printer.PutInt64(musage.mem.SwapCached)
+	printer.PutKey("active")
+	printer.PutInt64(musage.mem.Active)
+	printer.PutKey("inactive")
+	printer.PutInt64(musage.mem.Inactive)
+	printer.PutKey("swap_total")
+	printer.PutInt64(musage.mem.SwapTotal)
+	printer.PutKey("swap_free")
+	printer.PutInt64(musage.mem.SwapFree)
+	printer.PutKey("dirty")
+	printer.PutInt64(musage.mem.Dirty)
+	printer.PutKey("writeback")
+	printer.PutInt64(musage.mem.Writeback)
+	printer.PutKey("anon_pages")
+	printer.PutInt64(musage.mem.AnonPages)
+	printer.PutKey("mapped")
+	printer.PutInt64(musage.mem.Mapped)
+	printer.PutKey("shmem")
+	printer.PutInt64(musage.mem.Shmem)
+	printer.PutKey("slab")
+	printer.PutInt64(musage.mem.Slab)
+	printer.PutKey("s_reclaimable")
+	printer.PutInt64(musage.mem.SReclaimable)
+	printer.PutKey("s_unreclaim")
+	printer.PutInt64(musage.mem.SUnreclaim)
+	printer.PutKey("kernel_stack")
+	printer.PutInt64(musage.mem.KernelStack)
+	printer.PutKey("page_tables")
+	printer.PutInt64(musage.mem.PageTables)
+	printer.PutKey("nfs_unstable")
+	printer.PutInt64(musage.mem.NFS_Unstable)
+	printer.PutKey("bounce")
+	printer.PutInt64(musage.mem.Bounce)
+	printer.PutKey("commit_limit")
+	printer.PutInt64(musage.mem.CommitLimit)
+	printer.PutKey("committed_as")
+	printer.PutInt64(musage.mem.Committed_AS)
+	printer.PutKey("anon_huge_pages")
+	printer.PutInt64(musage.mem.AnonHugePages)
+	printer.PutKey("huge_pages_total")
+	printer.PutInt64(musage.mem.HugePages_Total)
+	printer.PutKey("huge_pages_free")
+	printer.PutInt64(musage.mem.HugePages_Free)
+	printer.PutKey("huge_pages_rsvd")
+	printer.PutInt64(musage.mem.HugePages_Rsvd)
+	printer.PutKey("huge_pages_surp")
+	printer.PutInt64(musage.mem.HugePages_Surp)
+
+	printer.FinishObject()
 }
 
-func (entry *NetUsageEntry) WriteJsonTo(buf *bytes.Buffer) {
-	buf.WriteString(
-		fmt.Sprintf(`{"rxkbyteps":%.2f,"rxpktps":%.2f,"rxerrps":%.2f,"rxdropps":%.2f,"txkbyteps":%.2f,"txpktps":%.2f,"txerrps":%.2f,"txdropps":%.2f}`,
-			entry.RxBytesPerSec/1024.0, entry.RxPacketsPerSec,
-			entry.RxErrorsPerSec, entry.RxDropsPerSec,
-			entry.TxBytesPerSec/1024.0, entry.TxPacketsPerSec,
-			entry.TxErrorsPerSec, entry.TxDropsPerSec))
+func (entry *NetUsageEntry) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+
+	printer.PutKey("rxkbyteps")
+	printer.PutFloatFmt(entry.RxBytesPerSec/1024.0, "%.2f")
+	printer.PutKey("rxpktps")
+	printer.PutFloatFmt(entry.RxPacketsPerSec, "%.2f")
+	printer.PutKey("rxerrps")
+	printer.PutFloatFmt(entry.RxErrorsPerSec, "%.2f")
+	printer.PutKey("rxdropps")
+	printer.PutFloatFmt(entry.RxDropsPerSec, "%.2f")
+	printer.PutKey("txkbyteps")
+	printer.PutFloatFmt(entry.TxBytesPerSec/1024.0, "%.2f")
+	printer.PutKey("txpktps")
+	printer.PutFloatFmt(entry.TxPacketsPerSec, "%.2f")
+	printer.PutKey("txerrps")
+	printer.PutFloatFmt(entry.TxErrorsPerSec, "%.2f")
+	printer.PutKey("txdropps")
+	printer.PutFloatFmt(entry.TxDropsPerSec, "%.2f")
+
+	printer.FinishObject()
 }