Fix all go vet non-constant string errors

Author: daniel-nichter

event/event.go

@@ -58,8 +58,10 @@ func SetReceiver(r Receiver) {
 	return
 }
 
-var subscribers = []Receiver{}
-var submux = &sync.Mutex{}
+var (
+	subscribers = []Receiver{}
+	submux      = &sync.Mutex{}
+)
 
 func Subscribe(r Receiver) {
 	submux.Lock()
@@ -90,6 +92,15 @@ func Sendf(eventName string, msg string, args ...interface{}) {
 	})
 }
 
+func Error(eventName string, msg string) {
+	send(Event{
+		Ts:      time.Now(),
+		Event:   eventName,
+		Message: msg,
+		Error:   true,
+	})
+}
+
 // Errorf sends an event flagged as an error with a formatted message.
 func Errorf(eventName string, msg string, args ...interface{}) {
 	send(Event{
@@ -139,6 +150,10 @@ func (s MonitorReceiver) Sendf(eventName string, msg string, args ...interface{}
 	})
 }
 
+func (s MonitorReceiver) Error(eventName string, msg string) {
+	s.Errorf(eventName, "%s", msg)
+}
+
 func (s MonitorReceiver) Errorf(eventName string, msg string, args ...interface{}) {
 	send(Event{
 		Ts:        time.Now(),
@@ -151,8 +166,10 @@ func (s MonitorReceiver) Errorf(eventName string, msg string, args ...interface{
 
 // --------------------------------------------------------------------------
 
-var stdout = log.New(os.Stdout, "", log.LstdFlags|log.Lmicroseconds)
-var stderr = log.New(os.Stderr, "", log.LstdFlags|log.Lmicroseconds)
+var (
+	stdout = log.New(os.Stdout, "", log.LstdFlags|log.Lmicroseconds)
+	stderr = log.New(os.Stderr, "", log.LstdFlags|log.Lmicroseconds)
+)
 
 // Log is the default Receiver that uses the Go built-in log package to print
 // certain events to STDOUT and error events to STDERR. Call SetReceiver to

heartbeat/reader.go

@@ -33,10 +33,12 @@ type Lag struct {
 	Replica      bool
 }
 
-var ReadTimeout = 2 * time.Second
-var ReadErrorWait = 1 * time.Second
-var NoHeartbeatWait = 3 * time.Second
-var ReplCheckWait = 3 * time.Second
+var (
+	ReadTimeout     = 2 * time.Second
+	ReadErrorWait   = 1 * time.Second
+	NoHeartbeatWait = 3 * time.Second
+	ReplCheckWait   = 3 * time.Second
+)
 
 // BlipReader reads heartbeats from BlipWriter.
 type BlipReader struct {
@@ -165,7 +167,7 @@ func (r *BlipReader) run() {
 			r.Unlock()
 			msg := fmt.Sprintf("not a replica: %s=%d (retry in %s)", r.replCheck, isRepl, ReplCheckWait)
 			blip.Debug("%s: %s", r.monitorId, msg)
-			status.Monitor(r.monitorId, status.HEARTBEAT_READER, msg)
+			status.Monitor(r.monitorId, status.HEARTBEAT_READER, "%s", msg)
 			time.Sleep(ReplCheckWait)
 			continue
 		}

monitor/engine.go

@@ -93,16 +93,16 @@ func (e *Engine) DB() *sql.DB {
 // calls. Serialization is handled by the only caller: LevelCollector.ChangePlan().
 func (e *Engine) Prepare(ctx context.Context, plan blip.Plan, before, after func()) error {
 	blip.Debug("%s: prepare %s (%s)", e.monitorId, plan.Name, plan.Source)
-	e.event.Sendf(event.ENGINE_PREPARE, plan.Name)
-	status.Monitor(e.monitorId, status.ENGINE_PREPARE, plan.Name)
+	e.event.Sendf(event.ENGINE_PREPARE, "%s", plan.Name)
+	status.Monitor(e.monitorId, status.ENGINE_PREPARE, "%s", plan.Name)
 	defer status.RemoveComponent(e.monitorId, status.ENGINE_PREPARE)
 
 	// Report last error, if any
 	var lerr error
 	defer func() {
 		if lerr != nil {
-			e.event.Errorf(event.ENGINE_PREPARE_ERROR, lerr.Error())
-			status.Monitor(e.monitorId, "error:"+status.ENGINE_PREPARE, lerr.Error())
+			e.event.Error(event.ENGINE_PREPARE_ERROR, lerr.Error())
+			status.Monitor(e.monitorId, "error:"+status.ENGINE_PREPARE, "%s", lerr.Error())
 		} else {
 			// success
 			status.RemoveComponent(e.monitorId, "error:"+status.ENGINE_PREPARE)
@@ -233,8 +233,8 @@ func (e *Engine) Prepare(ctx context.Context, plan blip.Plan, before, after func
 
 	e.Unlock() // UNLOCK plan ---------------------------------------
 
-	status.Monitor(e.monitorId, status.ENGINE_PLAN, plan.Name)
-	e.event.Sendf(event.ENGINE_PREPARE_SUCCESS, plan.Name)
+	status.Monitor(e.monitorId, status.ENGINE_PLAN, "%s", plan.Name)
+	e.event.Sendf(event.ENGINE_PREPARE_SUCCESS, "%s", plan.Name)
 
 	status.Monitor(e.monitorId, status.ENGINE_PREPARE, "%s: level-collector after callback", plan.Name)
 	after() // notify caller (lco.changePlan) that we have swapped the plan
@@ -271,10 +271,10 @@ func (e *Engine) Collect(emrCtx context.Context, interval uint, levelName string
 	}
 	if domains == nil {
 		blip.Debug("Engine.Stop was called, dropping interval %d level %s", interval, levelName)
-		return []*blip.Metrics{&blip.Metrics{Values: map[string][]blip.MetricValue{}}}, nil // see return guarantee in Collect comment
+		return []*blip.Metrics{{Values: map[string][]blip.MetricValue{}}}, nil // see return guarantee in Collect comment
 	}
 	blip.Debug("%s: %s: collect", e.monitorId, coId)
-	status.Monitor(e.monitorId, status.ENGINE_COLLECT, coId+": collecting")
+	status.Monitor(e.monitorId, status.ENGINE_COLLECT, "%s", coId+": collecting")
 
 	// Collect metrics for each domain in parallel (limit: CollectParallel)
 	sem := make(chan bool, CollectParallel) // semaphore for CollectParallel
@@ -362,7 +362,7 @@ SWEEP:
 	metrics[0].End = time.Now()
 
 	// Log collector errors and update collector status
-	status.Monitor(e.monitorId, status.ENGINE_COLLECT, coId+": logging errors")
+	status.Monitor(e.monitorId, status.ENGINE_COLLECT, "%s", coId+": logging errors")
 	errCount := 0
 	for domain, err := range errs {
 		switch err {
@@ -376,7 +376,7 @@ SWEEP:
 			errCount += 1
 			errMsg := fmt.Sprintf("%s/%s: %s", coId, domain, err)
 			status.Monitor(e.monitorId, "error:"+domain, "at %s: %s", metrics[0].Begin, errMsg)
-			e.event.Errorf(event.COLLECTOR_ERROR, errMsg) // log by default
+			e.event.Error(event.COLLECTOR_ERROR, errMsg) // log by default
 		}
 	}
 
@@ -493,7 +493,7 @@ func (cl *clutch) collect(m blip.Metrics, sem chan bool) {
 
 	if cl.running {
 		// Collector fault: it didn't terminate itself at CMR
-		cl.event.Errorf(event.COLLECTOR_FAULT, fmt.Sprintf("%s: metrics from interval %d will be dropped if the collector recovers: %+v", cl.domain, cl.m.Interval, cl))
+		cl.event.Errorf(event.COLLECTOR_FAULT, "%s: metrics from interval %d will be dropped if the collector recovers: %+v", cl.domain, cl.m.Interval, cl)
 		cl.fence = m.Interval
 		if cl.cancel != nil {
 			cl.cancel()
@@ -546,7 +546,7 @@ func (cl *clutch) collect(m blip.Metrics, sem chan bool) {
 			b := make([]byte, 4096)
 			n := runtime.Stack(b, false)
 			perr := fmt.Errorf("PANIC: monitor ID %s: %s: %v\n%s", cl.m.MonitorId, cl.domain, r, string(b[0:n]))
-			cl.event.Errorf(event.COLLECTOR_PANIC, perr.Error())
+			cl.event.Error(event.COLLECTOR_PANIC, perr.Error())
 		}
 		cancel() // local cancel, not cl.cancel, in case goroutine is behind the fence
 		cl.Lock()
@@ -562,7 +562,6 @@ func (cl *clutch) collect(m blip.Metrics, sem chan bool) {
 				cl.domain, cl.stopTime.Sub(cl.startTime), cl.pending, cl.err)
 		}
 		cl.Unlock()
-
 	}()
 
 	// ----------------------------------------------------------------------

monitor/level_collector.go

@@ -108,9 +108,11 @@ func TickerDuration(d, e time.Duration) {
 // act like 1s has elapsed. This is for test plans with realistic whole-second
 // durations. The RBB tests use 100ms/100ms because that test plan is design for
 // 100ms intervals, so it can run through 5 intervals in about 500ms.
-var tickerMux = &sync.Mutex{}        // make go test -race happy
-var tickerDuration = 1 * time.Second // used for testing
-var timeElapsed = 1 * time.Second    // used for testing
+var (
+	tickerMux      = &sync.Mutex{}   // make go test -race happy
+	tickerDuration = 1 * time.Second // used for testing
+	timeElapsed    = 1 * time.Second // used for testing
+)
 
 // recvMetrics receives metrics on metricsChan and send them to all the sinks.
 // This is a goroutine run by keepRecvMetrics and restarted by keepRecvMetrics
@@ -123,7 +125,7 @@ func (c *lco) recvMetrics(stopSinksChan, doneChan chan struct{}) {
 			b := make([]byte, 4096)
 			n := runtime.Stack(b, false)
 			perr := fmt.Errorf("PANIC: sinks: %s: %v\n%s", c.monitorId, r, string(b[0:n]))
-			c.event.Errorf(event.LCO_RECEIVER_PANIC, perr.Error())
+			c.event.Error(event.LCO_RECEIVER_PANIC, perr.Error())
 		}
 	}()
 RECV:
@@ -145,11 +147,11 @@ RECV:
 				coId := fmt.Sprintf("%s/%s/%d", m.Plan, m.Level, m.Interval)
 				for _, sink := range c.sinks {
 					sinkName := sink.Name()
-					status.Monitor(c.monitorId, status.LEVEL_SINKS, coId+": sending to "+sinkName)
+					status.Monitor(c.monitorId, status.LEVEL_SINKS, "%s", coId+": sending to "+sinkName)
 					err := sink.Send(context.Background(), m) // @todo ctx with timeout
 					if err != nil {
 						c.event.Errorf(event.SINK_SEND_ERROR, "%s :%s", sinkName, err) // log by default
-						status.Monitor(c.monitorId, "error:"+sinkName, err.Error())
+						status.Monitor(c.monitorId, "error:"+sinkName, "%s", err.Error())
 					} else {
 						status.RemoveComponent(c.monitorId, "error:"+sinkName)
 					}
@@ -279,8 +281,8 @@ func (c *lco) collect(interval uint, levelName string, startTime time.Time) {
 	blip.Debug("%s: level %s: done in %s", c.monitorId, levelName, metrics[0].End.Sub(metrics[0].Begin))
 
 	if err != nil {
-		status.Monitor(c.monitorId, "error:collect", err.Error())
-		c.event.Errorf(event.ENGINE_COLLECT_ERROR, err.Error())
+		status.Monitor(c.monitorId, "error:collect", "%s", err.Error())
+		c.event.Error(event.ENGINE_COLLECT_ERROR, err.Error())
 	} else {
 		status.RemoveComponent(c.monitorId, "error:collect")
 	}
@@ -368,7 +370,7 @@ func (c *lco) changePlan(ctx context.Context, doneChan chan struct{}, newState,
 	oldPlanName := c.plan.Name
 	c.stateMux.Unlock()
 	change := fmt.Sprintf("state:%s plan:%s -> state:%s plan:%s", oldState, oldPlanName, newState, newPlanName)
-	c.event.Sendf(event.CHANGE_PLAN, change)
+	c.event.Sendf(event.CHANGE_PLAN, "%s", change)
 
 	// Load new plan from plan loader, which contains all plans. Try forever because
 	// that's what this func/gouroutine does: try forever (caller's expect that).
@@ -385,8 +387,8 @@ func (c *lco) changePlan(ctx context.Context, doneChan chan struct{}, newState,
 		}
 
 		errMsg := fmt.Sprintf("%s: error loading new plan %s: %s (retrying)", change, newPlanName, err)
-		status.Monitor(c.monitorId, status.LEVEL_CHANGE_PLAN, errMsg)
-		c.event.Sendf(event.CHANGE_PLAN_ERROR, errMsg)
+		status.Monitor(c.monitorId, status.LEVEL_CHANGE_PLAN, "%s", errMsg)
+		c.event.Sendf(event.CHANGE_PLAN_ERROR, "%s", errMsg)
 		time.Sleep(2 * time.Second)
 	}
 
@@ -428,8 +430,8 @@ func (c *lco) changePlan(ctx context.Context, doneChan chan struct{}, newState,
 		// Changing state/plan always resumes (if paused); in fact, it's the
 		// only way to resume after Pause is called
 		c.paused = false
-		status.Monitor(c.monitorId, status.LEVEL_STATE, newState)
-		status.Monitor(c.monitorId, status.LEVEL_PLAN, newPlan.Name)
+		status.Monitor(c.monitorId, status.LEVEL_STATE, "%s", newState)
+		status.Monitor(c.monitorId, status.LEVEL_PLAN, "%s", newPlan.Name)
 		status.Monitor(c.monitorId, status.LEVEL_COLLECTOR, "running since %s", blip.FormatTime(time.Now()))
 		blip.Debug("%s: resume", c.monitorId)
 
@@ -466,7 +468,7 @@ func (c *lco) changePlan(ctx context.Context, doneChan chan struct{}, newState,
 	}
 
 	status.RemoveComponent(c.monitorId, status.LEVEL_CHANGE_PLAN)
-	c.event.Sendf(event.CHANGE_PLAN_SUCCESS, change)
+	c.event.Sendf(event.CHANGE_PLAN_SUCCESS, "%s", change)
 }
 
 // Pause pauses metrics collection until ChangePlan is called. Run still runs,

monitor/loader.go

@@ -168,8 +168,10 @@ func (ml *Loader) start(m *loadedMonitor) error {
 // [ 1, 10) = <1s startup
 // [10, 50] = ~1s
 // (50,inf) = >1s + 1s per 50 [e.g. 100=2s, 200=4s]
-const min_wait = 20
-const max_wait = 100
+const (
+	min_wait = 20
+	max_wait = 100
+)
 
 func wait(n int) int {
 	if n <= 1 {
@@ -243,7 +245,7 @@ func (ml *Loader) Load(ctx context.Context) error {
 			}
 		}
 		if errMsg != "" {
-			event.Errorf(event.MONITORS_STOPLOSS, errMsg)
+			event.Error(event.MONITORS_STOPLOSS, errMsg)
 			return ErrStopLoss
 		}
 	}

monitor/monitor.go

@@ -155,7 +155,7 @@ func (m *Monitor) Stop() error {
 		m.db.Close()
 	}
 
-	event.Sendf(event.MONITOR_STOPPED, m.monitorId)
+	event.Sendf(event.MONITOR_STOPPED, "%s", m.monitorId)
 	status.Monitor(m.monitorId, status.MONITOR, "stopped at %s", blip.FormatTime(time.Now()))
 	return nil
 }
@@ -259,7 +259,7 @@ func (m *Monitor) startup() error {
 			m.runMux.Lock()
 			m.db = db
 			m.dsn = dsnRedacted
-			status.Monitor(m.monitorId, status.MONITOR_DSN, dsnRedacted)
+			status.Monitor(m.monitorId, status.MONITOR_DSN, "%s", dsnRedacted)
 			m.runMux.Unlock()
 			break
 		}
@@ -377,7 +377,7 @@ func (m *Monitor) startup() error {
 		if m.cfg.Exporter.Mode == blip.EXPORTER_MODE_LEGACY {
 			blip.Debug("%s: legacy mode", m.monitorId)
 			status.Monitor(m.monitorId, status.MONITOR, "running in exporter legacy mode")
-			m.event.Sendf(event.MONITOR_STARTED, m.dsn)
+			m.event.Sendf(event.MONITOR_STARTED, "%s", m.dsn)
 			return nil
 		}
 	}
@@ -452,7 +452,7 @@ func (m *Monitor) startup() error {
 		m.lco.ChangePlan(blip.STATE_ACTIVE, m.cfg.Plan) // start LCO directly
 	}
 
-	m.event.Sendf(event.MONITOR_STARTED, m.dsn)
+	m.event.Sendf(event.MONITOR_STARTED, "%s", m.dsn)
 	return nil
 }
 
@@ -491,7 +491,7 @@ func (m *Monitor) stop(lock bool, caller string) {
 
 func (m *Monitor) setErr(err error, isPanic bool) {
 	if err != nil {
-		m.event.Errorf(event.MONITOR_ERROR, err.Error())
+		m.event.Error(event.MONITOR_ERROR, err.Error())
 		status.Monitor(m.monitorId, "error:"+status.MONITOR, "error: %s", err)
 	} else {
 		status.RemoveComponent(m.monitorId, "error:"+status.MONITOR)

monitor/plan_changer.go

@@ -115,7 +115,7 @@ func NewPlanChanger(args PlanChangerArgs) *planChanger {
 // setErr sets the last internal error reported by Status.
 func (pch *planChanger) setErr(err error) {
 	if err != nil {
-		status.Monitor(pch.monitorId, "error:"+status.PLAN_CHANGER, err.Error())
+		status.Monitor(pch.monitorId, "error:"+status.PLAN_CHANGER, "%s", err.Error())
 	} else {
 		status.RemoveComponent(pch.monitorId, "error:"+status.PLAN_CHANGER)
 	}

plan/loader.go

@@ -171,7 +171,7 @@ func (pl *Loader) LoadShared(cfg blip.ConfigPlans, dbMaker blip.DbFactory) error
 
 // LoadMonitor loads monitor plans: config.monitors.*.Plans.
 func (pl *Loader) LoadMonitor(mon blip.ConfigMonitor, dbMaker blip.DbFactory) error {
-	event.Sendf(event.PLANS_LOAD_MONITOR, mon.MonitorId)
+	event.Sendf(event.PLANS_LOAD_MONITOR, "%s", mon.MonitorId)
 
 	if mon.Plans.Table == "" && len(mon.Plans.Files) == 0 {
 		blip.Debug("monitor %s uses only shared plans", mon.MonitorId)

server/api.go

@@ -89,7 +89,7 @@ func (api *API) Run() error {
 			blip.Debug("shutdown")
 			return nil
 		default:
-			event.Errorf(event.SERVER_API_ERROR, err.Error())
+			event.Errorf(event.SERVER_API_ERROR, "%s", err.Error())
 			time.Sleep(1 * time.Second) // between crashes
 		}
 	}