perfmonger 0.10.2 → 0.11.0

data/core/perfmonger-plot-formatter.go

@@ -11,23 +11,30 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
+	"regexp"
 	"sort"
 
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
 )
 
 type CmdOption struct {
-	DiskFile       string
-	CpuFile        string
-	PerfmongerFile string
+	DiskFile        string
+	CpuFile         string
+	PerfmongerFile  string
+	disk_only       string
+	disk_only_regex *regexp.Regexp
 }
 
 func parseArgs() *CmdOption {
+	var err error
+
 	opt := new(CmdOption)
 
 	flag.StringVar(&opt.DiskFile, "diskfile", "./disk.dat", "Disk performance data file")
 	flag.StringVar(&opt.CpuFile, "cpufile", "./cpu.dat", "CPU performance data file")
 	flag.StringVar(&opt.PerfmongerFile, "perfmonger", "", "Perfmonger log file")
+	flag.StringVar(&opt.disk_only, "disk-only",
+		"", "Select disk devices by regex")
 
 	flag.Parse()
 
@@ -36,6 +43,11 @@ func parseArgs() *CmdOption {
 		os.Exit(1)
 	}
 
+	opt.disk_only_regex, err = regexp.Compile(opt.disk_only)
+	if err != nil {
+		panic(err)
+	}
+
 	return opt
 }
 
@@ -192,7 +204,9 @@ func main() {
 		}
 
 		// Disk usage
-		dusage, err := ss.GetDiskUsage(prev_rec.Time, prev_rec.Disk, cur_rec.Time, cur_rec.Disk)
+		dusage, err := ss.GetDiskUsage1(prev_rec.Time, prev_rec.Disk,
+			cur_rec.Time, cur_rec.Disk,
+			opt.disk_only_regex)
 		if err != nil {
 			panic(err)
 		}

data/core/perfmonger-recorder.go

@@ -43,6 +43,8 @@ type RecorderOption struct {
 	targetDisks         *map[string]bool
 	background          bool
 	gzip                bool
+	color               bool
+	pretty              bool
 }
 
 var option RecorderOption
@@ -86,6 +88,10 @@ func parseArgs() {
 		"", "Run perfmonger-player to show JSON output")
 	flag.BoolVar(&option.gzip, "gzip",
 		false, "Save a logfile in gzipped format")
+	flag.BoolVar(&option.color, "color",
+		false, "Colored output (for live subcmd)")
+	flag.BoolVar(&option.pretty, "pretty",
+		false, "Pretty output (for live subcmd)")
 
 	flag.Parse()
 
@@ -190,7 +196,7 @@ func main() {
 	parseArgs()
 
 	hostname, _ := os.Hostname()
-	cheader := &ss.CommonHeader{ss.Linux, hostname, time.Now()}
+	cheader := &ss.CommonHeader{Platform: ss.Linux, Hostname: hostname, StartTime: time.Now()}
 
 	platform_header := ss.NewPlatformHeader()
 
@@ -206,7 +212,15 @@ func main() {
 	var player_stdout io.ReadCloser = nil
 
 	if option.player_bin != "" {
-		player_cmd = exec.Command(option.player_bin)
+		if option.color {
+			if option.pretty {
+				player_cmd = exec.Command(option.player_bin, "-color", "-pretty")
+			} else {
+				player_cmd = exec.Command(option.player_bin, "-color")
+			}
+		} else {
+			player_cmd = exec.Command(option.player_bin)
+		}
 		player_stdin, err = player_cmd.StdinPipe()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Failed to get stdin of %s", option.player_bin)

data/core/perfmonger-summarizer.go

@@ -3,7 +3,6 @@
 package main
 
 import (
-	"bytes"
 	"encoding/gob"
 	"flag"
 	"fmt"
@@ -12,6 +11,7 @@ import (
 	"regexp"
 	"sort"
 
+	projson "github.com/hayamiz/go-projson"
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
 )
 
@@ -137,32 +137,38 @@ func main() {
 	interval := lst_record.Time.Sub(fst_record.Time)
 
 	if option.json {
-		buf := bytes.NewBuffer([]byte{})
+		printer := projson.NewPrinter()
 
-		buf.WriteString(fmt.Sprintf(`{"exectime":%.3f`, interval.Seconds()))
+		printer.BeginObject()
+		printer.PutKey("exectime")
+		printer.PutFloatFmt(interval.Seconds(), "%.3f")
 		if cpu_usage != nil {
-			buf.WriteString(`,"cpu":`)
-			cpu_usage.WriteJsonTo(buf)
+			printer.PutKey("cpu")
+			cpu_usage.WriteJsonTo(printer)
 		}
 
 		if intr_usage != nil {
-			buf.WriteString(`,"intr":`)
-			intr_usage.WriteJsonTo(buf)
+			printer.PutKey("intr")
+			intr_usage.WriteJsonTo(printer)
 		}
 
 		if disk_usage != nil {
-			buf.WriteString(`,"disk":`)
-			disk_usage.WriteJsonTo(buf)
+			printer.PutKey("disk")
+			disk_usage.WriteJsonTo(printer)
 		}
 
 		if net_usage != nil {
-			buf.WriteString(`,"net":`)
-			net_usage.WriteJsonTo(buf)
+			printer.PutKey("net")
+			net_usage.WriteJsonTo(printer)
 		}
 
-		buf.WriteByte('}')
+		printer.FinishObject()
 
-		fmt.Println(buf.String())
+		if str, err := printer.String(); err != nil {
+			fmt.Println("skip by err")
+		} else {
+			fmt.Println(str)
+		}
 	} else {
 		if option.title == "" {
 			fmt.Println("== performance summary ==")

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,52 @@ 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))
+var UseColor = false
+
+func SetUseColor(use_color bool) {
+	UseColor = use_color
 }
 
-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)
+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 +253,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(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 (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 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(buf *bytes.Buffer) {
+func (dusage *DiskUsage) WriteJsonTo(printer *projson.JsonPrinter) {
 	var devices []string
 
 	for device, _ := range *dusage {
@@ -263,23 +324,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 +532,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 +542,45 @@ 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)
 	}
 
-	buf.WriteByte('}')
+	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")