gofmt

Author: Peter Mogensen

metric/client.go

@@ -14,7 +14,7 @@ type Client struct {
 	done *sync.WaitGroup
 
 	// protects the flusher map
-	fmu sync.Mutex
+	fmu      sync.Mutex
 	flushers map[time.Duration]*flusher
 
 	// The flusher handling meters which have been given no specific
@@ -40,7 +40,7 @@ func init() {
 func NewClient(sinkf SinkFactory, opts ...MOption) (client *Client) {
 
 	client = &Client{}
-	client.done =  new(sync.WaitGroup)
+	client.done = new(sync.WaitGroup)
 	client.flushers = make(map[time.Duration]*flusher)
 
 	client.defaultFlusher = newFlusher(0)
@@ -69,8 +69,8 @@ func (c *Client) SetOptions(opts ...MOption) {
 	}
 
 	c.fmu.Lock()
-	if f,ok := conf["flushInterval"]; ok {
-		if d, ok := f.(time.Duration) ; ok {
+	if f, ok := conf["flushInterval"]; ok {
+		if d, ok := f.(time.Duration); ok {
 			c.defaultFlusher.setInterval(d)
 		}
 	}
@@ -90,7 +90,7 @@ func (c *Client) SetSink(sinkf SinkFactory) {
 
 	c.sinkf = sinkf
 	c.defaultFlusher.setSink(sinkf)
-	for _,f := range c.flushers {
+	for _, f := range c.flushers {
 		if sinkf == nil {
 			f.setSink(&nilSinkFactory{})
 		} else {
@@ -116,7 +116,7 @@ func (c *Client) Start() {
 
 	go c.defaultFlusher.rundyn()
 
-	for _,f := range c.flushers {
+	for _, f := range c.flushers {
 		c.done.Add(1)
 		f.run(c.done)
 	}
@@ -141,7 +141,7 @@ func (c *Client) Stop() {
 
 	c.defaultFlusher.stop()
 
-	for _,f := range c.flushers {
+	for _, f := range c.flushers {
 		f.stop()
 	}
 	c.done.Wait()
@@ -159,7 +159,7 @@ func (c *Client) register(m Meter, opts ...MOption) {
 		o(conf)
 	}
 
-	if fi,ok := conf["flushInterval"]; ok {
+	if fi, ok := conf["flushInterval"]; ok {
 		flush = fi.(time.Duration)
 		if f, ok = c.flushers[flush]; !ok {
 			f = newFlusher(flush)
@@ -202,7 +202,7 @@ func (c *Client) Gauge(name string, val uint64, flush bool) {
 // Timer creates an ad-hoc timer metric event.
 // If flush is true, the sink will be instructed to flush data immediately
 func (c *Client) Timer(name string, d time.Duration, flush bool) {
-	val := d.Nanoseconds()/int64(1000000)
+	val := d.Nanoseconds() / int64(1000000)
 	c.defaultFlusher.RecordNumeric64(MeterTimer, name, Numeric64{Type: Uint64, value: uint64(val)}, flush)
 }
 

metric/counter.go

@@ -27,9 +27,9 @@ func (c *Client) NewCounter(name string, opts ...MOption) *Counter {
 }
 
 func (c *Counter) Flush(s Sink) {
-	val := atomic.SwapInt64(&c.val,0)
+	val := atomic.SwapInt64(&c.val, 0)
 	if val != 0 {
-		n := Numeric64{Type:Int64, value: uint64(val)}
+		n := Numeric64{Type: Int64, value: uint64(val)}
 		s.RecordNumeric64(MeterCounter, c.name, n)
 	}
 }

metric/event.go

@@ -1,51 +1,50 @@
 package metric
 
 import (
+	"runtime"
 	"sync"
 	"sync/atomic"
-	"runtime"
 )
 
 // An almost lock-free FIFO buffer
 // Locks are only used when flushing
 
-const bufferMaskBits = 8 // determines the size of the buffer 
-const bufferSize     = uint64(1) << bufferMaskBits
-const bufferMask     = bufferSize - 1
+const bufferMaskBits = 8 // determines the size of the buffer
+const bufferSize = uint64(1) << bufferMaskBits
+const bufferMask = bufferSize - 1
 
-const indexStart     = 0
+const indexStart = 0
 
 type event struct {
 	seq uint64
 	val uint64 // union of 64-bit numeric values including float64
-	mu sync.Mutex
-	cv *sync.Cond
+	mu  sync.Mutex
+	cv  *sync.Cond
 }
 
 type dequeueFunc func(f Sink, val uint64)
 
 // A generic stream of values which all have to be propagated to the sink.
 type eventStream struct {
-	widx uint64 // index of next free slot
-	ridx uint64 // index of next unread slot
+	widx  uint64 // index of next free slot
+	ridx  uint64 // index of next unread slot
 	slots [bufferSize]event
 
 	flusher Flusher
 
 	dequeue dequeueFunc
 
-	name string
+	name  string
 	mtype int
 }
 
-
 func (c *Client) newEventStream(name string, mtype int, dqf dequeueFunc) *eventStream {
-	e := &eventStream{name: name, mtype: mtype, dequeue: dqf, widx: indexStart, ridx: indexStart }
+	e := &eventStream{name: name, mtype: mtype, dequeue: dqf, widx: indexStart, ridx: indexStart}
 
 	// make sure first slot is not valid from the start due to zero-value
 	// and set all sequences to their "old" value
 	for i := range e.slots {
-		e.slots[i].seq = uint64(i)-bufferSize
+		e.slots[i].seq = uint64(i) - bufferSize
 		e.slots[i].cv = sync.NewCond(&(e.slots[i].mu))
 	}
 	return e
@@ -56,7 +55,7 @@ func (e *eventStream) SetFlusher(f Flusher) {
 }
 
 // Flush as much as possible
-func (e* eventStream) Flush(f Sink) {
+func (e *eventStream) Flush(f Sink) {
 
 	var idx uint64
 
@@ -80,20 +79,19 @@ func (e* eventStream) Flush(f Sink) {
 	atomic.StoreUint64(&(e.ridx), ridx)
 }
 
-
 func (e *eventStream) Name() string {
 	return e.name
 }
 
 func (e *eventStream) MeterType() int {
-       return e.mtype
+	return e.mtype
 }
 
 func (e *eventStream) Enqueue(val uint64) {
 
-	var ridx    uint64
-	var widx    uint64
-	var idx     uint64
+	var ridx uint64
+	var widx uint64
+	var idx uint64
 
 	// First get a slot
 	widx = atomic.AddUint64(&(e.widx), 1)
@@ -113,7 +111,7 @@ func (e *eventStream) Enqueue(val uint64) {
 			// We have not catched up
 			e.slots[idx].val = val
 			// mark the slot written
-			oldmark := atomic.SwapUint64(&(e.slots[idx].seq),widx)
+			oldmark := atomic.SwapUint64(&(e.slots[idx].seq), widx)
 
 			// test to see if someone was waiting for that mark
 			if oldmark != widx-bufferSize {
@@ -135,16 +133,16 @@ func (e *eventStream) Enqueue(val uint64) {
 		// we need to make an atomic operation which:
 		// 1) Decides whether to go to sleep and wait for our slot to be ready.
 		// 2) Informs the writer of the slot that we want to be woken.
-		
+
 		// The slot we are waiting for have sequence 1 buffersize back from rdix,
 		// if it's still not ready
 
-		oldmark := ridx-bufferSize
+		oldmark := ridx - bufferSize
 
 		idx2 := ridx & bufferMask // from here on we look at the stale read index.
 		e.slots[idx2].mu.Lock()
 		// Try skew the mark to indicate we're waiting
-		mustwait := atomic.CompareAndSwapUint64(&(e.slots[idx2].seq),oldmark,oldmark+1)
+		mustwait := atomic.CompareAndSwapUint64(&(e.slots[idx2].seq), oldmark, oldmark+1)
 		if mustwait {
 			// We have now at the same time determined that the slot is not ready
 			// and set it to indicate that who ever writes it must signal us.
@@ -159,12 +157,12 @@ func (e *eventStream) Enqueue(val uint64) {
 			if actualmark == oldmark+1 {
 				// skewed - join the waiters.
 				e.slots[idx2].cv.Wait()
-			} else {  // stuff can happen fast
+			} else { // stuff can happen fast
 				// The slot was actually up to date - so advance the reader
 				e.flusher.FlushMeter(e)
 			}
 		}
 		e.slots[idx2].mu.Unlock()
-		
+
 	}
 }

metric/flusher.go

@@ -1,8 +1,8 @@
 package metric
 
 import (
-	"time"
 	"sync"
+	"time"
 )
 
 // A flusher is either run with a fixed flushinterval with a go-routine which
@@ -21,17 +21,17 @@ type Flusher struct {
 
 type flusher struct {
 	// Tell the flusher to exit - or (for defaultFlusher) restart
-	stopChan     chan struct{}
+	stopChan chan struct{}
 	// Kick the flusher to reconsider interval (used for defaultFlusher)
-	kickChan     chan struct{}
+	kickChan chan struct{}
 
 	interval time.Duration
 
-	mu sync.Mutex
+	mu     sync.Mutex
 	meters []Meter
 
 	// only set once by the run/rundyn method to fix how the flusher is used.
-	ftype int   
+	ftype int
 
 	sink Sink
 }
@@ -91,7 +91,7 @@ RUNNING: // two cases - either with a flush or not
 		if interval == 0 {
 			// sit here waiting doing nothing
 			select {
-			case <- f.stopChan:
+			case <-f.stopChan:
 				break RUNNING
 			case <-f.kickChan:
 			}
@@ -100,13 +100,13 @@ RUNNING: // two cases - either with a flush or not
 		LOOP:
 			for {
 				select {
-				case <- f.stopChan:
+				case <-f.stopChan:
 					ticker.Stop()
 					break RUNNING
 				case <-f.kickChan:
 					ticker.Stop()
 					break LOOP // to test to make a new ticker
-				case <- ticker.C:
+				case <-ticker.C:
 					f.Flush()
 				}
 			}
@@ -132,15 +132,15 @@ func (f *flusher) run(done *sync.WaitGroup) {
 		// don't start a meaningless flusher
 		return
 	}
-	
+
 	ticker := time.NewTicker(f.interval)
 LOOP:
 	for {
 		select {
-		case <- f.stopChan:
+		case <-f.stopChan:
 			ticker.Stop()
 			break LOOP
-		case <- ticker.C:
+		case <-ticker.C:
 			f.Flush()
 		}
 	}
@@ -170,13 +170,11 @@ func (f *flusher) register(m Meter) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.meters = append(f.meters, m)
-	if a,ok := m.(AutoFlusher); ok {
+	if a, ok := m.(AutoFlusher); ok {
 		a.SetFlusher(Flusher{f})
 	}
 }
 
-
-
 func (f *flusher) Record(mtype int, name string, value interface{}, flush bool) {
 	f.mu.Lock()
 	f.sink.Record(mtype, name, value)
@@ -195,10 +193,8 @@ func (f *flusher) RecordNumeric64(mtype int, name string, value Numeric64, flush
 	f.mu.Unlock()
 }
 
-
 func (f *flusher) FlushSink() {
 	f.mu.Lock()
 	f.sink.Flush()
 	f.mu.Unlock()
 }
-

metric/gauge.go

@@ -1,8 +1,8 @@
 package metric
 
 import (
-	"sync/atomic"
 	"math"
+	"sync/atomic"
 )
 
 // A client maintained gauge which is only sampled regulary without information loss
@@ -38,6 +38,7 @@ func NewGauge(name string, opts ...MOption) *GaugeUint64 {
 func (c *Client) NewGauge(name string, opts ...MOption) *GaugeUint64 {
 	return c.NewGaugeUint64(name, opts...)
 }
+
 /*==================================================================*/
 
 // NewGaugeUint64 returns a standard gauge.
@@ -50,7 +51,7 @@ func (c *Client) NewGaugeUint64(name string, opts ...MOption) *GaugeUint64 {
 // Flush to implement Meter interface
 func (g *GaugeUint64) Flush(s Sink) {
 	val := atomic.LoadUint64(&g.val)
-	n := Numeric64{Type:Uint64, value: val}
+	n := Numeric64{Type: Uint64, value: val}
 	s.RecordNumeric64(MeterGauge, g.name, n)
 }
 
@@ -95,7 +96,7 @@ func (c *Client) NewGaugeInt64(name string, opts ...MOption) *GaugeInt64 {
 
 func (g *GaugeInt64) Flush(s Sink) {
 	val := atomic.LoadInt64(&g.val)
-	n := Numeric64{Type:Int64, value: uint64(val)}
+	n := Numeric64{Type: Int64, value: uint64(val)}
 	s.RecordNumeric64(MeterGauge, g.name, n)
 }
 
@@ -154,6 +155,6 @@ func (g *GaugeFloat64) Value() float64 {
 
 func (g *GaugeFloat64) Flush(s Sink) {
 	val := atomic.LoadUint64(&g.val)
-	n := Numeric64{Type:Float64, value: val}
+	n := Numeric64{Type: Float64, value: val}
 	s.RecordNumeric64(MeterGauge, g.name, n)
 }

metric/histotimer.go

@@ -36,7 +36,7 @@ func NewTimer(name string, opts ...MOption) *Timer {
 }
 
 func (c *Client) NewTimer(name string, opts ...MOption) *Timer {
- 	dequeuef := func(f Sink, val uint64) {
+	dequeuef := func(f Sink, val uint64) {
 		n := Numeric64{Type: Uint64, value: val}
 		f.RecordNumeric64(MeterTimer, name, n)
 	}
@@ -48,5 +48,5 @@ func (c *Client) NewTimer(name string, opts ...MOption) *Timer {
 // Sample records a new duration event.
 func (t *Timer) Sample(d time.Duration) {
 	e := (*eventStream)(t)
-	e.Enqueue(uint64(d.Nanoseconds()/int64(1000000)))
+	e.Enqueue(uint64(d.Nanoseconds() / int64(1000000)))
 }