More UI improvements

 * Show help if no report elements are chosen
 ```
 $ ./bin/gupta
 Usage of ./bin/gupta:
   -c	poll CPU usage
   -i int
     	polling inteval (default 5)
   -l	Poll load
   -m	Poll memory
   -n string
     	Network usage (interface)
   -p string
     	Poll disk usage (partition)
  ```

  * format the report as JSON based on the flags passed:
  ```
  $ ./bin/gupta -m  -i 1
  Welcome to gupta version 0.0.1
  {"timestamp":"now","metrics":[{"memory":{"total":"16080192KB","used":"13686028KB","free":"2394164KB"}}]}
  {"timestamp":"now","metrics":[{"memory":{"total":"16080192KB","used":"13686028KB","free":"2394164KB"}}]}
  $ ./bin/gupta -c  -i 1
  Welcome to gupta version 0.0.1
  {"timestamp":"now","metrics":[{"cpu usage":"3.52%"}]}
  {"timestamp":"now","metrics":[{"cpu usage":"4.29%"}]}
  {"timestamp":"now","metrics":[{"cpu usage":"3.54%"}]}
  {"timestamp":"now","metrics":[{"cpu usage":"4.23%"}]}
  {"timestamp":"now","metrics":[{"cpu usage":"11.28%"}]}
  ^C
  $ ./bin/gupta -c -m  -i 1
  Welcome to gupta version 0.0.1
  {"timestamp":"now","metrics":[{"cpu usage":"6.52%"},{"memory":{"total":"16080192KB","used":"13678752KB","free":"2401440KB"}}]}
  {"timestamp":"now","metrics":[{"cpu usage":"7.56%"},{"memory":{"total":"16080192KB","used":"13678500KB","free":"2401692KB"}}]}
  {"timestamp":"now","metrics":[{"cpu usage":"5.03%"},{"memory":{"total":"16080192KB","used":"13678248KB","free":"2401944KB"}}]}
  {"timestamp":"now","metrics":[{"cpu usage":"4.53%"},{"memory":{"total":"16080192KB","used":"13678248KB","free":"2401944KB"}}]}
  {"timestamp":"now","metrics":[{"cpu usage":"4.27%"},{"memory":{"total":"16080192KB","used":"13677996KB","free":"2402196KB"}}]}
  ^C
  ```

Makefile

@@ -9,7 +9,7 @@ build:
 	go build -o bin/gupta cmd/main.go
 
 run:
-	./bin/gupta -f 2
+	./bin/gupta -i 2
 
 install:
 	install -m 755 bin/gupta $(DEST)

cmd/main.go

@@ -20,12 +20,18 @@ func readProcStatLine(r *os.File) string {
 	return line
 }
 
+var Usage = func() {
+	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+
+	flag.PrintDefaults()
+}
+
 func main() {
-	var freq int
+	var interval int
 	var partition, netInterface string
 	var load, memory, cpu bool
 
-	flag.IntVar(&freq, "i", 5, "polling inteval")
+	flag.IntVar(&interval, "i", 5, "polling inteval")
 	flag.BoolVar(&memory, "m", false, "Poll memory")
 	flag.BoolVar(&load, "l", false, "Poll load")
 	flag.BoolVar(&cpu, "c", false, "poll CPU usage")
@@ -34,25 +40,35 @@ func main() {
 
 	flag.Parse()
 
+	if load == false && memory == false && cpu == false {
+		Usage()
+		os.Exit(1)
+	}
 	fmt.Println(gupta.Hello())
 	r, _ := os.Open("/proc/stat")
 	m, _ := os.Open("/proc/meminfo")
+	defer r.Close()
+	defer m.Close()
 
 	for true {
-		line := readProcStatLine(r)
-		time.Sleep(time.Second)
-		lineNew := readProcStatLine(r)
-		cpustat := gupta.NewCPUStat(line, lineNew)
-		fmt.Printf("CPU usage %.2f%%\n", cpustat.CPUUsage())
-		mem := gupta.NewMemory(m)
-		//fmt.Printf("Memory free %d\n", mem.Total())
 		report := gupta.GuptaReport{}
-		report.MemoryUsage = mem
+		line := readProcStatLine(r)
+		time.Sleep(time.Duration(interval) * time.Second)
+		if cpu {
+			lineNew := readProcStatLine(r)
+			cpustat := gupta.NewCPUStat(line, lineNew)
+			report.CPUUsage = &cpustat
+		}
+		if memory {
+			mem := gupta.NewMemory(m)
+			report.MemoryUsage = &mem
+		}
 		writer := os.Stdout
 		enc := json.NewEncoder(writer)
 		if err := enc.Encode(&report); err != nil {
 			log.Println(err)
 		}
+		r.Seek(0, 0)
 		m.Seek(0, 0)
 	}
 }

gupta.go

@@ -1,6 +1,7 @@
 package gupta
 
 import (
+	"encoding/json"
 	"fmt"
 	"strconv"
 	"strings"
@@ -21,12 +22,29 @@ func Run(load, cpu, memory bool, partition, networkInterface string) (cpuLoad, c
 
 type GuptaReport struct {
 	LoadAvarage float64
-	CPUUsage    float64
-	MemoryUsage Memory `json:"memory,omitempty"`
+	CPUUsage    *CPUStat `json:"cpu usage, omitempty"`
+	MemoryUsage *Memory  `json:"memory,omitempty"`
 }
 
-func (g *GuptaReport) GetCPULoad() string {
-	return fmt.Sprintf("%.2f", g.LoadAvarage)
+// usually you'd want a g GuptaReport reciever here ...
+// but than you could now check for the object properties ...
+func (g *GuptaReport) MarshalJSON() ([]byte, error) {
+	report := []byte("{\"timestamp\": \"now\", \"metrics\": [")
+	if g.CPUUsage != nil {
+		usage, _ := json.Marshal(g.CPUUsage)
+		report = append(report, usage...)
+	}
+
+	if g.MemoryUsage != nil {
+		if g.CPUUsage != nil {
+			report = append(report, []byte(",")...)
+		}
+		usage, _ := json.Marshal(g.MemoryUsage)
+		report = append(report, usage...)
+	}
+
+	report = append(report, []byte("]}")...)
+	return report, nil
 }
 
 // collect all CPU stat from /proc/cpustat
@@ -73,3 +91,9 @@ func NewCPUStat(procstatline, procstatlineNew string) CPUStat {
 	cpustat.ReadInfoNew(procstatlineNew)
 	return cpustat
 }
+
+func (c CPUStat) MarshalJSON() ([]byte, error) {
+	jsonData := []byte(
+		fmt.Sprintf("{\"cpu usage\": \"%.2f%%\"}", c.CPUUsage()))
+	return jsonData, nil
+}

gupta_test.go

@@ -45,16 +45,16 @@ func TestCPUStat(t *testing.T) {
 		// test we can get some report struct from gupta
 		report := GuptaReport{
 			LoadAvarage: 0.2,
-			CPUUsage:    0.2,
-			MemoryUsage: Memory{},
+			CPUUsage:    &cpustat,
+			MemoryUsage: &Memory{},
 		}
 
-		got := report.GetCPULoad()
-		want := "0.20"
+		got := report.CPUUsage.CPUUsage()
+		want := float64(68.00)
 		name := "CPULoad"
 
 		if got != want {
-			t.Errorf("got %s %s want %s", name, got, want)
+			t.Errorf("got %s %.2f want %.2f", name, got, want)
 		}
 
 	})

memory.go

@@ -15,7 +15,7 @@ type Memory struct {
 
 func (m Memory) MarshalJSON() ([]byte, error) {
 	jsonData := []byte(
-		fmt.Sprintf("{\"total\": \"%dKB\", \"used\": \"%dKB\", \"free\": \"%dKB\"}",
+		fmt.Sprintf("{\"memory\": {\"total\": \"%dKB\", \"used\": \"%dKB\", \"free\": \"%dKB\"}}",
 			m.Total, m.Used(), m.Free))
 	return jsonData, nil
 }

memory_test.go

@@ -3,7 +3,6 @@ package gupta
 import (
 	"bytes"
 	"encoding/json"
-	"fmt"
 	"strings"
 	"testing"
 )
@@ -32,7 +31,6 @@ func TestTotalMem(t *testing.T) {
 func TestUsedMem(t *testing.T) {
 	m := Memory{Total: uint64(2400), Free: uint64(1200)}
 	got := m.Used()
-	fmt.Println(got)
 	want := uint64(1200)
 	name := "used"
 	if got != want {
@@ -58,10 +56,8 @@ func TestNewMemory(t *testing.T) {
 		enc := json.NewEncoder(&buff)
 		enc.Encode(&mem)
 		report := buff.String()
-		fmt.Println(report)
 		reportFields := strings.Split(report, ":")
-		fmt.Println(reportFields[1])
-		if reportFields[1] != "\"16080192KB\",\"used\"" {
+		if reportFields[2] != "\"16080192KB\",\"used\"" {
 			t.Errorf("Encoding report failed")
 		}
 	})