refactor: fix many linter warnings

pkg/perfdata/perfdata.go

@@ -12,15 +12,15 @@ import (
 type UnitOfMeasurement int
 
 const (
-	UOM_NONE UnitOfMeasurement = iota
-	UOM_SECONDS
-	UOM_PERCENT
-	UOM_BYTES
-	UOM_KILOBYTES
-	UOM_MEGABYTES
-	UOM_GIGABYTES
-	UOM_TERABYTES
-	UOM_COUNTER
+	UomNone UnitOfMeasurement = iota
+	UomSeconds
+	UomPercent
+	UomBytes
+	UomKilobytes
+	UomMegabytes
+	UomGigabytes
+	UomTerabytes
+	UomCounter
 )
 
 func (u UnitOfMeasurement) String() string {
@@ -31,24 +31,24 @@ func (u UnitOfMeasurement) String() string {
 type perfDataBits int
 
 const (
-	PDAT_WARN perfDataBits = 1 << iota
-	PDAT_CRIT
-	PDAT_MIN
-	PDAT_MAX
+	PDatWarn perfDataBits = 1 << iota
+	PDatCrit
+	PDatMin
+	PDatMax
 )
 
 // Regexps used to check values and ranges in performance data records.
 var (
-	// Common value check regexp
+	// Common value check regexp.
 	vcRegexp = `^-?(0(\.\d*)?|[1-9]\d*(\.\d*)?|\.\d+)$`
-	// Compiled value check regexp
+	// Compiled value check regexp.
 	valueCheck = regexp.MustCompile(vcRegexp)
-	// Compiled range min value check
+	// Compiled range min value check.
 	rangeMinCheck = regexp.MustCompile(vcRegexp + `|^~$`)
 )
 
-// Performance data range
-type PerfDataRange struct {
+// Performance data range.
+type PDRange struct {
 	start  string
 	end    string
 	inside bool
@@ -56,54 +56,56 @@ type PerfDataRange struct {
 
 // Creates a performance data range from -inf to 0 and from the specified
 // value to +inf.
-func PDRMax(max string) *PerfDataRange {
+func PDRMax(max string) *PDRange {
 	if !valueCheck.MatchString(max) {
 		panic("invalid performance data range maximum value")
 	}
-	r := &PerfDataRange{}
-	r.start = "0"
-	r.end = max
-	return r
+	pdRange := &PDRange{}
+	pdRange.start = "0"
+	pdRange.end = max
+	return pdRange
 }
 
 // Creates a performance data range from -inf to the specified minimal value
 // and from the specified maximal value to +inf.
-func PDRMinMax(min, max string) *PerfDataRange {
+func PDRMinMax(min, max string) *PDRange {
 	if !valueCheck.MatchString(max) {
 		panic("invalid performance data range maximum value")
 	}
 	if !rangeMinCheck.MatchString(min) {
 		panic("invalid performance data range minimum value")
 	}
-	r := &PerfDataRange{}
-	r.start = min
-	r.end = max
-	return r
+	pdRange := &PDRange{}
+	pdRange.start = min
+	pdRange.end = max
+	return pdRange
 }
 
 // Inverts the range.
-func (r *PerfDataRange) Inside() *PerfDataRange {
+func (r *PDRange) Inside() *PDRange {
 	r.inside = true
 	return r
 }
 
 // Generates the range's string representation so it can be sent to the
 // monitoring system.
-func (r *PerfDataRange) String() string {
+func (r *PDRange) String() string {
 	var start, inside string
-	if r.start == "" {
+
+	switch r.start {
+	case "":
 		start = "~"
-	} else if r.start == "0" {
+	case "0":
 		start = ""
-	} else {
+	default:
 		start = r.start
 	}
+
 	if r.inside {
 		inside = "@"
-	} else {
-		inside = ""
 	}
-	return fmt.Sprintf("%s%s:%s", inside, start, r.end)
+
+	return inside + start + ":" + r.end
 }
 
 // Performance data, including a label, units, a value, warning/critical
@@ -113,7 +115,7 @@ type PerfData struct {
 	units      UnitOfMeasurement
 	bits       perfDataBits
 	value      string
-	warn, crit PerfDataRange
+	warn, crit PDRange
 	min, max   string
 }
 
@@ -122,36 +124,36 @@ func New(label string, units UnitOfMeasurement, value string) *PerfData {
 	if value != "" && !valueCheck.MatchString(value) {
 		panic("invalid value")
 	}
-	r := &PerfData{}
-	r.Label = label
-	r.units = units
+	pdRange := &PerfData{}
+	pdRange.Label = label
+	pdRange.units = units
 	if value == "" {
-		r.value = "U"
+		pdRange.value = "U"
 	} else {
-		r.value = value
+		pdRange.value = value
 	}
-	return r
+	return pdRange
 }
 
 // Set the warning range for the performance data record.
-func (d *PerfData) SetWarn(r *PerfDataRange) {
+func (d *PerfData) SetWarn(r *PDRange) {
 	d.warn = *r
-	d.bits = d.bits | PDAT_WARN
+	d.bits |= PDatWarn
 }
 
 // Set the critical range for the performance data record.
-func (d *PerfData) SetCrit(r *PerfDataRange) {
+func (d *PerfData) SetCrit(r *PDRange) {
 	d.crit = *r
-	d.bits = d.bits | PDAT_CRIT
+	d.bits |= PDatCrit
 }
 
-// Set the performance data's minimal value
+// Set the performance data's minimal value.
 func (d *PerfData) SetMin(min string) {
 	if !valueCheck.MatchString(min) {
 		panic("invalid value")
 	}
 	d.min = min
-	d.bits = d.bits | PDAT_MIN
+	d.bits |= PDatMin
 }
 
 // Set the performance data's maximal value.
@@ -160,38 +162,38 @@ func (d *PerfData) SetMax(max string) {
 		panic("invalid value")
 	}
 	d.max = max
-	d.bits = d.bits | PDAT_MAX
+	d.bits |= PDatMax
 }
 
 // Converts performance data to a string which may be read by the monitoring
 // system.
 func (d *PerfData) String() string {
-	var sb strings.Builder
+	var strBuilder strings.Builder
 	needsQuotes := strings.ContainsAny(d.Label, " '=\"")
 	if needsQuotes {
-		sb.WriteString("'")
+		strBuilder.WriteString("'")
 	}
-	sb.WriteString(strings.ReplaceAll(d.Label, "'", "''"))
+	strBuilder.WriteString(strings.ReplaceAll(d.Label, "'", "''"))
 	if needsQuotes {
-		sb.WriteString("'")
+		strBuilder.WriteString("'")
 	}
-	sb.WriteString("=")
-	sb.WriteString(fmt.Sprintf("%s%s;", d.value, d.units.String()))
-	if d.bits&PDAT_WARN != 0 {
-		sb.WriteString(d.warn.String())
+	strBuilder.WriteString("=")
+	strBuilder.WriteString(fmt.Sprintf("%s%s;", d.value, d.units.String()))
+	if d.bits&PDatWarn != 0 {
+		strBuilder.WriteString(d.warn.String())
 	}
-	sb.WriteString(";")
-	if d.bits&PDAT_CRIT != 0 {
-		sb.WriteString(d.crit.String())
+	strBuilder.WriteString(";")
+	if d.bits&PDatCrit != 0 {
+		strBuilder.WriteString(d.crit.String())
 	}
-	sb.WriteString(";")
-	if d.bits&PDAT_MIN != 0 {
-		sb.WriteString(d.min)
+	strBuilder.WriteString(";")
+	if d.bits&PDatMin != 0 {
+		strBuilder.WriteString(d.min)
 	}
-	sb.WriteString(";")
-	if d.bits&PDAT_MAX != 0 {
-		sb.WriteString(d.max)
+	strBuilder.WriteString(";")
+	if d.bits&PDatMax != 0 {
+		strBuilder.WriteString(d.max)
 	}
 
-	return sb.String()
+	return strBuilder.String()
 }

pkg/perfdata/perfdata_test.go

@@ -78,7 +78,7 @@ func TestPdrMinMax(t *testing.T) {
 }
 
 func TestPdrInside(t *testing.T) {
-	pdr := &PerfDataRange{}
+	pdr := &PDRange{}
 	pdr = pdr.Inside()
 	assert(t, pdr.inside, "Inside flag should be set")
 	pdr = pdr.Inside()
@@ -87,14 +87,14 @@ func TestPdrInside(t *testing.T) {
 
 func TestPdrString(t *testing.T) {
 	type Test struct {
-		pdr PerfDataRange
+		pdr PDRange
 		out string
 	}
 	tests := []Test{
-		{pdr: PerfDataRange{start: "Y", end: "X"}, out: "Y:X"},
-		{pdr: PerfDataRange{end: "X"}, out: "~:X"},
-		{pdr: PerfDataRange{start: "0", end: "X"}, out: ":X"},
-		{pdr: PerfDataRange{inside: true, start: "Y", end: "X"}, out: "@Y:X"},
+		{pdr: PDRange{start: "Y", end: "X"}, out: "Y:X"},
+		{pdr: PDRange{end: "X"}, out: "~:X"},
+		{pdr: PDRange{start: "0", end: "X"}, out: ":X"},
+		{pdr: PDRange{inside: true, start: "Y", end: "X"}, out: "@Y:X"},
 	}
 
 	for _, test := range tests {

pkg/plugin/plugin.go

@@ -58,17 +58,22 @@ func (p *Plugin) SetState(status Status, message string) {
 }
 
 // AddLine adds the specified string to the extra output text buffer.
-func (p *Plugin) AddLine(format string, data ...interface{}) {
+func (p *Plugin) AddLine(line string) {
 	if p.extraText == nil {
 		p.extraText = list.New()
 	}
-	p.extraText.PushBack(fmt.Sprintf(format, data...))
+	p.extraText.PushBack(line)
+}
+
+// AddLinef formats the input and adds it to the text buffer.
+func (p *Plugin) AddLinef(format string, data ...interface{}) {
+	p.AddLine(fmt.Sprintf(format, data...))
 }
 
 // AddLines add the specified `lines` to the output text.
 func (p *Plugin) AddLines(lines []string) {
 	for _, line := range lines {
-		p.AddLine("%s", line)
+		p.AddLine(line)
 	}
 }
 
@@ -78,7 +83,7 @@ func (p *Plugin) AddLines(lines []string) {
 func (p *Plugin) AddPerfData(pd *perfdata.PerfData) {
 	_, exists := p.perfData[pd.Label]
 	if exists {
-		panic(fmt.Sprintf("duplicate performance data %s", pd.Label))
+		panic("duplicate performance data " + pd.Label)
 	}
 	p.perfData[pd.Label] = pd
 }
@@ -87,30 +92,31 @@ func (p *Plugin) AddPerfData(pd *perfdata.PerfData) {
 // and performance data, before exiting with the code corresponding to the
 // status.
 func (p *Plugin) Done() {
-	var sb strings.Builder
-	sb.WriteString(p.name)
-	sb.WriteString(" ")
-	sb.WriteString(p.status.String())
-	sb.WriteString(": ")
-	sb.WriteString(p.message)
+	var strBuilder strings.Builder
+	strBuilder.WriteString(p.name)
+	strBuilder.WriteString(" ")
+	strBuilder.WriteString(p.status.String())
+	strBuilder.WriteString(": ")
+	strBuilder.WriteString(p.message)
 	if len(p.perfData) > 0 {
-		sb.WriteString(" | ")
+		strBuilder.WriteString(" | ")
 		needSep := false
-		for k := range p.perfData {
+		for _, data := range p.perfData {
 			if needSep {
-				sb.WriteString(", ")
+				strBuilder.WriteString(", ")
 			} else {
 				needSep = true
 			}
-			sb.WriteString(p.perfData[k].String())
+			strBuilder.WriteString(data.String())
 		}
 	}
 	if p.extraText != nil {
 		for em := p.extraText.Front(); em != nil; em = em.Next() {
-			sb.WriteString("\n")
-			sb.WriteString(em.Value.(string))
+			strBuilder.WriteString("\n")
+			//nolint:forcetypeassert // we want to panic if this isn't a string
+			strBuilder.WriteString(em.Value.(string))
 		}
 	}
-	fmt.Println(sb.String())
+	fmt.Println(strBuilder.String())
 	os.Exit(int(p.status))
 }

pkg/program/program.go

@@ -6,4 +6,4 @@ type Program interface {
 	Done()
 }
 
-type ProgramBuilder func() Program
+type Builder func() Program