rename collector subpackage

metrics/docker.go

@@ -0,0 +1,95 @@
+package metrics
+
+import (
+	api "github.com/fsouza/go-dockerclient"
+)
+
+// Docker collector
+type Docker struct {
+	Metrics
+	id         string
+	client     *api.Client
+	running    bool
+	stream     chan Metrics
+	done       chan bool
+	lastCpu    float64
+	lastSysCpu float64
+}
+
+func NewDocker(client *api.Client, id string) *Docker {
+	return &Docker{
+		Metrics: Metrics{},
+		id:      id,
+		client:  client,
+		stream:  make(chan Metrics),
+		done:    make(chan bool),
+	}
+}
+
+func (c *Docker) Start() {
+	stats := make(chan *api.Stats)
+
+	go func() {
+		opts := api.StatsOptions{
+			ID:     c.id,
+			Stats:  stats,
+			Stream: true,
+			Done:   c.done,
+		}
+		c.client.Stats(opts)
+		c.running = false
+	}()
+
+	go func() {
+		defer close(c.stream)
+		for s := range stats {
+			c.ReadCPU(s)
+			c.ReadMem(s)
+			c.ReadNet(s)
+			c.stream <- c.Metrics
+		}
+	}()
+
+	c.running = true
+}
+
+func (c *Docker) Running() bool {
+	return c.running
+}
+
+func (c *Docker) Stream() chan Metrics {
+	return c.stream
+}
+
+// Stop collector
+func (c *Docker) Stop() {
+	c.done <- true
+}
+
+func (c *Docker) ReadCPU(stats *api.Stats) {
+	ncpus := float64(len(stats.CPUStats.CPUUsage.PercpuUsage))
+	total := float64(stats.CPUStats.CPUUsage.TotalUsage)
+	system := float64(stats.CPUStats.SystemCPUUsage)
+
+	cpudiff := total - c.lastCpu
+	syscpudiff := system - c.lastSysCpu
+
+	c.CPUUtil = round((cpudiff / syscpudiff * 100) * ncpus)
+	c.lastCpu = total
+	c.lastSysCpu = system
+}
+
+func (c *Docker) ReadMem(stats *api.Stats) {
+	c.MemUsage = int64(stats.MemoryStats.Usage)
+	c.MemLimit = int64(stats.MemoryStats.Limit)
+	c.MemPercent = round((float64(c.MemUsage) / float64(c.MemLimit)) * 100)
+}
+
+func (c *Docker) ReadNet(stats *api.Stats) {
+	var rx, tx int64
+	for _, network := range stats.Networks {
+		rx += int64(network.RxBytes)
+		tx += int64(network.TxBytes)
+	}
+	c.NetRx, c.NetTx = rx, tx
+}

metrics/main.go

@@ -0,0 +1,25 @@
+package metrics
+
+import (
+	"math"
+)
+
+type Metrics struct {
+	CPUUtil    int
+	NetTx      int64
+	NetRx      int64
+	MemLimit   int64
+	MemPercent int
+	MemUsage   int64
+}
+
+type Collector interface {
+	Stream() chan Metrics
+	Running() bool
+	Start()
+	Stop()
+}
+
+func round(num float64) int {
+	return int(num + math.Copysign(0.5, num))
+}

metrics/mock.go

@@ -0,0 +1,52 @@
+package metrics
+
+import (
+	"math/rand"
+	"time"
+)
+
+// Mock collector
+type Mock struct {
+	Metrics
+	stream chan Metrics
+	done   chan bool
+}
+
+func NewMock() *Mock {
+	c := &Mock{
+		Metrics: Metrics{},
+		stream:  make(chan Metrics),
+		done:    make(chan bool),
+	}
+	c.MemLimit = 2147483648
+	go c.run()
+	return c
+}
+
+func (c *Mock) run() {
+	rand.Seed(int64(time.Now().Nanosecond()))
+	for {
+		c.CPUUtil += rand.Intn(10)
+		if c.CPUUtil > 100 {
+			c.CPUUtil = 0
+		}
+		c.CPUUtil += rand.Intn(2)
+		c.NetTx += rand.Int63n(30)
+		c.NetRx += rand.Int63n(30)
+		c.MemUsage += rand.Int63n(c.MemLimit / 16)
+		if c.MemUsage > c.MemLimit {
+			c.MemUsage = 0
+		}
+		c.MemPercent = round((float64(c.MemUsage) / float64(c.MemLimit)) * 100)
+		c.stream <- c.Metrics
+		time.Sleep(1 * time.Second)
+	}
+}
+
+func (c *Mock) Stream() chan Metrics {
+	return c.stream
+}
+
+func (c *Mock) Stop() {
+	c.done <- true
+}