perfmonger 0.10.2 → 0.12.1

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()
 }

data/core/subsystem/usage_test.go

@@ -1,7 +1,6 @@
 package subsystem
 
 import (
-	"bytes"
 	"encoding/json"
 	"math"
 	"regexp"
@@ -9,6 +8,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	projson "github.com/hayamiz/go-projson"
 )
 
 func isValidJson(byt []byte) bool {
@@ -89,7 +90,7 @@ func TestGetCoreUsage(t *testing.T) {
 		usage.Steal == 0 &&
 		usage.Guest == 0 &&
 		usage.GuestNice == 0) {
-		t.Error("usage is not 0%, want 0%")
+		t.Error("usage is not 0 percent, want 0 percent")
 	}
 
 	// should return error if c1.Uptime() is larger than c2.Uptime()
@@ -120,10 +121,14 @@ func TestGetCoreUsage(t *testing.T) {
 		t.Errorf("usage.Sys = %v, want 25.0", usage.User)
 	}
 
-	buf := bytes.NewBuffer([]byte{})
-	usage.WriteJsonTo(buf)
-	if !isValidJson(buf.Bytes()) {
-		t.Errorf("Invalid JSON: %s", buf.String())
+	printer := projson.NewPrinter()
+	usage.WriteJsonTo(printer)
+	if str, err := printer.String(); err != nil {
+		t.Errorf("failed to print JSON")
+	} else {
+		if !isValidJson([]byte(str)) {
+			t.Errorf("Invalid JSON: %s", str)
+		}
 	}
 }
 
@@ -207,15 +212,20 @@ func TestGetCpuUsage(t *testing.T) {
 		t.Errorf("usage.Sys = %v, want 25.0", usage.CoreUsages[1].User)
 	}
 
-	buf := bytes.NewBuffer([]byte{})
-	usage.WriteJsonTo(buf)
-	if !isValidJson(buf.Bytes()) {
-		t.Errorf("Invalid JSON: %s", buf.String())
+	printer := projson.NewPrinter()
+	usage.WriteJsonTo(printer)
+	str, err := printer.String()
+	if err != nil {
+		t.Errorf("failed printing JSON")
+	} else {
+		if !isValidJson([]byte(str)) {
+			t.Errorf("Invalid JSON: %s", str)
+		}
 	}
 
 	assertHasKey := func(key_path string) {
-		if !jsonHasKey(buf.Bytes(), key_path) {
-			t.Errorf("%v is not present in JSON:\n%v", key_path, buf.String())
+		if !jsonHasKey([]byte(str), key_path) {
+			t.Errorf("%v is not present in JSON:\n%v", key_path, str)
 		}
 	}
 	assertHasKey("num_core")
@@ -291,10 +301,15 @@ func TestDiskUsage(t *testing.T) {
 		t.Errorf("sda.RdSectors = %v, want %v", (*usage)["sda"].RdSectors, 350)
 	}
 
-	buf := bytes.NewBuffer([]byte{})
-	usage.WriteJsonTo(buf)
-	if !isValidJson(buf.Bytes()) {
-		t.Errorf("invalid json: %s", buf.String())
+	printer := projson.NewPrinter()
+	usage.WriteJsonTo(printer)
+	str, err := printer.String()
+	if err != nil {
+		t.Errorf("failed printing JSON")
+	} else {
+		if !isValidJson([]byte(str)) {
+			t.Errorf("invalid json: %s", str)
+		}
 	}
 
 	d1.Entries = append(d1.Entries, NewDiskStatEntry())
@@ -347,15 +362,20 @@ func TestDiskUsage(t *testing.T) {
 		t.Errorf("total.RdSectors = %v, want %v", (*usage)["total"].RdSectors, 350)
 	}
 
-	buf = bytes.NewBuffer([]byte{})
-	usage.WriteJsonTo(buf)
-	if !isValidJson(buf.Bytes()) {
-		t.Errorf("invalid json: %s", buf.String())
+	printer = projson.NewPrinter()
+	usage.WriteJsonTo(printer)
+	str, err = printer.String()
+	if err != nil {
+		t.Errorf("failed printing JSON")
+	} else {
+		if !isValidJson([]byte(str)) {
+			t.Errorf("invalid json: %s", str)
+		}
 	}
 
 	assertHasKey := func(key_path string) {
-		if !jsonHasKey(buf.Bytes(), key_path) {
-			t.Errorf("%v is not present in JSON:\n%v", key_path, buf.String())
+		if !jsonHasKey([]byte(str), key_path) {
+			t.Errorf("%v is not present in JSON:\n%v", key_path, str)
 		}
 	}
 	assertHasKey("devices")
@@ -428,10 +448,15 @@ func TestGetNetUsage(t *testing.T) {
 		t.Errorf("lo.RxPacketsPerSec = %v, want %v", (*usage)["lo"].RxPacketsPerSec, 100.0/interval)
 	}
 
-	buf := bytes.NewBuffer([]byte{})
-	usage.WriteJsonTo(buf)
-	if !isValidJson(buf.Bytes()) {
-		t.Errorf("invalid json: %s", buf.String())
+	printer := projson.NewPrinter()
+	usage.WriteJsonTo(printer)
+	str, err := printer.String()
+	if err != nil {
+		t.Errorf("failed printing JSON")
+	} else {
+		if !isValidJson([]byte(str)) {
+			t.Errorf("invalid json: %s", str)
+		}
 	}
 
 	n1.Entries = append(n1.Entries, NewNetStatEntry())
@@ -483,15 +508,20 @@ func TestGetNetUsage(t *testing.T) {
 			(100.0+150.0)/interval)
 	}
 
-	buf = bytes.NewBuffer([]byte{})
-	usage.WriteJsonTo(buf)
-	if !isValidJson(buf.Bytes()) {
-		t.Errorf("invalid json: %s", buf.String())
+	printer = projson.NewPrinter()
+	usage.WriteJsonTo(printer)
+	str, err = printer.String()
+	if err != nil {
+		t.Errorf("failed printing JSON")
+	} else {
+		if !isValidJson([]byte(str)) {
+			t.Errorf("invalid json: %s", str)
+		}
 	}
 
 	assertHasKey := func(key_path string) {
-		if !jsonHasKey(buf.Bytes(), key_path) {
-			t.Errorf("%v is not present in JSON:\n%v", key_path, buf.String())
+		if !jsonHasKey([]byte(str), key_path) {
+			t.Errorf("%v is not present in JSON:\n%v", key_path, str)
 		}
 	}
 	assertHasKey("devices")