chore: clean up import shadowing issues (#12588)

cmd/telegraf/main.go

@@ -8,9 +8,9 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/awnumar/memguard"
 	"github.com/urfave/cli/v2"
 
-	"github.com/awnumar/memguard"
 	"github.com/influxdata/telegraf/config"
 	"github.com/influxdata/telegraf/internal"
 	"github.com/influxdata/telegraf/internal/goplugin"
@@ -207,15 +207,7 @@ func runApp(args []string, outputBuffer io.Writer, pprof Server, c TelegrafConfi
 		case cCtx.Bool("sample-config"):
 			filters := processFilterFlags(cCtx)
 
-			printSampleConfig(
+			printSampleConfig(outputBuffer, filters)
-				outputBuffer,
-				filters.section,
-				filters.input,
-				filters.output,
-				filters.aggregator,
-				filters.processor,
-				filters.secretstore,
-			)
 			return nil
 		}
 
@@ -352,15 +344,7 @@ func runApp(args []string, outputBuffer io.Writer, pprof Server, c TelegrafConfi
 					// e.g. telegraf config --section-filter inputs
 					filters := processFilterFlags(cCtx)
 
-					printSampleConfig(
+					printSampleConfig(outputBuffer, filters)
-						outputBuffer,
-						filters.section,
-						filters.input,
-						filters.output,
-						filters.aggregator,
-						filters.processor,
-						filters.secretstore,
-					)
 					return nil
 				},
 			},

cmd/telegraf/printer.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/internal/choice"
 	"github.com/influxdata/telegraf/plugins/aggregators"
 	"github.com/influxdata/telegraf/plugins/inputs"
 	"github.com/influxdata/telegraf/plugins/outputs"
@@ -17,12 +18,10 @@ import (
 
 var (
 	// Default sections
-	sectionDefaults = []string{"global_tags", "agent", "secretstores",
+	sectionDefaults = []string{"global_tags", "agent", "secretstores", "outputs", "processors", "aggregators", "inputs"}
-		"outputs", "processors", "aggregators", "inputs"}
 
 	// Default input plugins
-	inputDefaults = []string{"cpu", "mem", "swap", "system", "kernel",
+	inputDefaults = []string{"cpu", "mem", "swap", "system", "kernel", "processes", "disk", "diskio"}
-		"processes", "disk", "diskio"}
 
 	// Default output plugins
 	outputDefaults = []string{}
@@ -101,25 +100,15 @@ var serviceInputHeader = `
 
 `
 
-func sliceContains(name string, list []string) bool {
-	for _, b := range list {
-		if b == name {
-			return true
-		}
-	}
-	return false
-}
-
 // printSampleConfig prints the sample config
-func printSampleConfig(
+func printSampleConfig(outputBuffer io.Writer, filters Filters) {
-	outputBuffer io.Writer,
+	sectionFilters := filters.section
-	sectionFilters []string,
+	inputFilters := filters.input
-	inputFilters []string,
+	outputFilters := filters.output
-	outputFilters []string,
+	aggregatorFilters := filters.aggregator
-	aggregatorFilters []string,
+	processorFilters := filters.processor
-	processorFilters []string,
+	secretstoreFilters := filters.secretstore
-	secretstoreFilters []string,
+
-) {
 	// print headers
 	outputBuffer.Write([]byte(header))
 
@@ -129,7 +118,7 @@ func printSampleConfig(
 	printFilteredGlobalSections(sectionFilters, outputBuffer)
 
 	// print secretstore plugins
-	if sliceContains("secretstores", sectionFilters) {
+	if choice.Contains("secretstores", sectionFilters) {
 		if len(secretstoreFilters) != 0 {
 			if len(secretstoreFilters) >= 3 && secretstoreFilters[1] != "none" {
 				fmt.Print(secretstoreHeader)
@@ -147,7 +136,7 @@ func printSampleConfig(
 	}
 
 	// print output plugins
-	if sliceContains("outputs", sectionFilters) {
+	if choice.Contains("outputs", sectionFilters) {
 		if len(outputFilters) != 0 {
 			if len(outputFilters) >= 3 && outputFilters[1] != "none" {
 				outputBuffer.Write([]byte(outputHeader))
@@ -159,7 +148,7 @@ func printSampleConfig(
 			// Print non-default outputs, commented
 			var pnames []string
 			for pname := range outputs.Outputs {
-				if !sliceContains(pname, outputDefaults) {
+				if !choice.Contains(pname, outputDefaults) {
 					pnames = append(pnames, pname)
 				}
 			}
@@ -168,7 +157,7 @@ func printSampleConfig(
 	}
 
 	// print processor plugins
-	if sliceContains("processors", sectionFilters) {
+	if choice.Contains("processors", sectionFilters) {
 		if len(processorFilters) != 0 {
 			if len(processorFilters) >= 3 && processorFilters[1] != "none" {
 				outputBuffer.Write([]byte(processorHeader))
@@ -185,7 +174,7 @@ func printSampleConfig(
 	}
 
 	// print aggregator plugins
-	if sliceContains("aggregators", sectionFilters) {
+	if choice.Contains("aggregators", sectionFilters) {
 		if len(aggregatorFilters) != 0 {
 			if len(aggregatorFilters) >= 3 && aggregatorFilters[1] != "none" {
 				outputBuffer.Write([]byte(aggregatorHeader))
@@ -202,7 +191,7 @@ func printSampleConfig(
 	}
 
 	// print input plugins
-	if sliceContains("inputs", sectionFilters) {
+	if choice.Contains("inputs", sectionFilters) {
 		if len(inputFilters) != 0 {
 			if len(inputFilters) >= 3 && inputFilters[1] != "none" {
 				outputBuffer.Write([]byte(inputHeader))
@@ -214,7 +203,7 @@ func printSampleConfig(
 			// Print non-default inputs, commented
 			var pnames []string
 			for pname := range inputs.Inputs {
-				if !sliceContains(pname, inputDefaults) {
+				if !choice.Contains(pname, inputDefaults) {
 					pnames = append(pnames, pname)
 				}
 			}
@@ -227,7 +216,7 @@ func printFilteredProcessors(processorFilters []string, commented bool, outputBu
 	// Filter processors
 	var pnames []string
 	for pname := range processors.Processors {
-		if sliceContains(pname, processorFilters) {
+		if choice.Contains(pname, processorFilters) {
 			pnames = append(pnames, pname)
 		}
 	}
@@ -245,7 +234,7 @@ func printFilteredAggregators(aggregatorFilters []string, commented bool, output
 	// Filter outputs
 	var anames []string
 	for aname := range aggregators.Aggregators {
-		if sliceContains(aname, aggregatorFilters) {
+		if choice.Contains(aname, aggregatorFilters) {
 			anames = append(anames, aname)
 		}
 	}
@@ -263,7 +252,7 @@ func printFilteredInputs(inputFilters []string, commented bool, outputBuffer io.
 	// Filter inputs
 	var pnames []string
 	for pname := range inputs.Inputs {
-		if sliceContains(pname, inputFilters) {
+		if choice.Contains(pname, inputFilters) {
 			pnames = append(pnames, pname)
 		}
 	}
@@ -311,7 +300,7 @@ func printFilteredOutputs(outputFilters []string, commented bool, outputBuffer i
 	var influxdbV2 string
 
 	for oname := range outputs.Outputs {
-		if sliceContains(oname, outputFilters) {
+		if choice.Contains(oname, outputFilters) {
 			// Make influxdb_v2 the exception and have it be first in the list
 			// Store it and add it later
 			if oname == "influxdb_v2" {
@@ -340,7 +329,7 @@ func printFilteredSecretstores(secretstoreFilters []string, commented bool, outp
 	// Filter secretstores
 	var snames []string
 	for sname := range secretstores.SecretStores {
-		if sliceContains(sname, secretstoreFilters) {
+		if choice.Contains(sname, secretstoreFilters) {
 			snames = append(snames, sname)
 		}
 	}
@@ -355,11 +344,11 @@ func printFilteredSecretstores(secretstoreFilters []string, commented bool, outp
 }
 
 func printFilteredGlobalSections(sectionFilters []string, outputBuffer io.Writer) {
-	if sliceContains("global_tags", sectionFilters) {
+	if choice.Contains("global_tags", sectionFilters) {
 		outputBuffer.Write([]byte(globalTagsConfig))
 	}
 
-	if sliceContains("agent", sectionFilters) {
+	if choice.Contains("agent", sectionFilters) {
 		outputBuffer.Write([]byte(agentConfig))
 	}
 }

plugins/inputs/dns_query/dns_query_test.go

@@ -30,9 +30,9 @@ func TestGathering(t *testing.T) {
 	var acc testutil.Accumulator
 	require.NoError(t, dnsConfig.Init())
 	require.NoError(t, acc.GatherError(dnsConfig.Gather))
-	metric, ok := acc.Get("dns_query")
+	m, ok := acc.Get("dns_query")
 	require.True(t, ok)
-	queryTime, ok := metric.Fields["query_time_ms"].(float64)
+	queryTime, ok := m.Fields["query_time_ms"].(float64)
 	require.True(t, ok)
 	require.NotEqual(t, float64(0), queryTime)
 }
@@ -52,9 +52,9 @@ func TestGatheringMxRecord(t *testing.T) {
 
 	require.NoError(t, dnsConfig.Init())
 	require.NoError(t, acc.GatherError(dnsConfig.Gather))
-	metric, ok := acc.Get("dns_query")
+	m, ok := acc.Get("dns_query")
 	require.True(t, ok)
-	queryTime, ok := metric.Fields["query_time_ms"].(float64)
+	queryTime, ok := m.Fields["query_time_ms"].(float64)
 	require.True(t, ok)
 	require.NotEqual(t, float64(0), queryTime)
 }

plugins/inputs/vsphere/client.go

@@ -117,7 +117,6 @@ func (cf *ClientFactory) testClient(ctx context.Context) error {
 		if err := cf.client.Client.SessionManager.Login(ctx2, auth); err != nil {
 			return fmt.Errorf("renewing authentication failed: %w", err)
 		}
-
 	}
 
 	return nil

plugins/inputs/x509_cert/x509_cert_test.go

@@ -426,9 +426,9 @@ func TestServerName(t *testing.T) {
 			if test.err {
 				require.Error(t, err)
 				return
-			} else {
-				require.NoError(t, err)
 			}
+			require.NoError(t, err)
+
 			u, err := url.Parse(test.url)
 			require.NoError(t, err)
 			require.Equal(t, test.expected, sc.serverName(u))

plugins/outputs/influxdb/http.go

@@ -121,72 +121,72 @@ type httpClient struct {
 	log telegraf.Logger
 }
 
-func NewHTTPClient(config HTTPConfig) (*httpClient, error) {
+func NewHTTPClient(cfg HTTPConfig) (*httpClient, error) {
-	if config.URL == nil {
+	if cfg.URL == nil {
 		return nil, ErrMissingURL
 	}
 
-	if config.Database == "" {
+	if cfg.Database == "" {
-		config.Database = defaultDatabase
+		cfg.Database = defaultDatabase
 	}
 
-	if config.Timeout == 0 {
+	if cfg.Timeout == 0 {
-		config.Timeout = defaultRequestTimeout
+		cfg.Timeout = defaultRequestTimeout
 	}
 
-	userAgent := config.UserAgent
+	userAgent := cfg.UserAgent
 	if userAgent == "" {
 		userAgent = internal.ProductToken()
 	}
 
-	if config.Headers == nil {
+	if cfg.Headers == nil {
-		config.Headers = make(map[string]string)
+		cfg.Headers = make(map[string]string)
 	}
-	config.Headers["User-Agent"] = userAgent
+	cfg.Headers["User-Agent"] = userAgent
-	for k, v := range config.Headers {
+	for k, v := range cfg.Headers {
-		config.Headers[k] = v
+		cfg.Headers[k] = v
 	}
 
 	var proxy func(*http.Request) (*url.URL, error)
-	if config.Proxy != nil {
+	if cfg.Proxy != nil {
-		proxy = http.ProxyURL(config.Proxy)
+		proxy = http.ProxyURL(cfg.Proxy)
 	} else {
 		proxy = http.ProxyFromEnvironment
 	}
 
-	if config.Serializer == nil {
+	if cfg.Serializer == nil {
-		config.Serializer = influx.NewSerializer()
+		cfg.Serializer = influx.NewSerializer()
 	}
 
 	var transport *http.Transport
-	switch config.URL.Scheme {
+	switch cfg.URL.Scheme {
 	case "http", "https":
 		transport = &http.Transport{
 			Proxy:           proxy,
-			TLSClientConfig: config.TLSConfig,
+			TLSClientConfig: cfg.TLSConfig,
 		}
 	case "unix":
 		transport = &http.Transport{
 			Dial: func(_, _ string) (net.Conn, error) {
 				return net.DialTimeout(
-					config.URL.Scheme,
+					cfg.URL.Scheme,
-					config.URL.Path,
+					cfg.URL.Path,
 					defaultRequestTimeout,
 				)
 			},
 		}
 	default:
-		return nil, fmt.Errorf("unsupported scheme %q", config.URL.Scheme)
+		return nil, fmt.Errorf("unsupported scheme %q", cfg.URL.Scheme)
 	}
 
 	client := &httpClient{
 		client: &http.Client{
-			Timeout:   config.Timeout,
+			Timeout:   cfg.Timeout,
 			Transport: transport,
 		},
 		createDatabaseExecuted: make(map[string]bool),
-		config:                 config,
+		config:                 cfg,
-		log:                    config.Log,
+		log:                    cfg.Log,
 	}
 	return client, nil
 }

plugins/outputs/influxdb/http_test.go

@@ -34,28 +34,28 @@ func getHTTPURL() *url.URL {
 }
 
 func TestHTTP_EmptyConfig(t *testing.T) {
-	config := influxdb.HTTPConfig{}
+	cfg := influxdb.HTTPConfig{}
-	_, err := influxdb.NewHTTPClient(config)
+	_, err := influxdb.NewHTTPClient(cfg)
 	require.Error(t, err)
 	require.Contains(t, err.Error(), influxdb.ErrMissingURL.Error())
 }
 
 func TestHTTP_MinimalConfig(t *testing.T) {
-	config := influxdb.HTTPConfig{
+	cfg := influxdb.HTTPConfig{
 		URL: getHTTPURL(),
 	}
-	_, err := influxdb.NewHTTPClient(config)
+	_, err := influxdb.NewHTTPClient(cfg)
 	require.NoError(t, err)
 }
 
 func TestHTTP_UnsupportedScheme(t *testing.T) {
-	config := influxdb.HTTPConfig{
+	cfg := influxdb.HTTPConfig{
 		URL: &url.URL{
 			Scheme: "foo",
 			Host:   "localhost",
 		},
 	}
-	_, err := influxdb.NewHTTPClient(config)
+	_, err := influxdb.NewHTTPClient(cfg)
 	require.Error(t, err)
 }
 
@@ -562,15 +562,15 @@ func TestHTTP_WritePathPrefix(t *testing.T) {
 	)
 	metrics := []telegraf.Metric{m}
 
-	config := influxdb.HTTPConfig{
+	cfg := influxdb.HTTPConfig{
 		URL:      u,
 		Database: "telegraf",
 		Log:      testutil.Logger{},
 	}
 
-	client, err := influxdb.NewHTTPClient(config)
+	client, err := influxdb.NewHTTPClient(cfg)
 	require.NoError(t, err)
-	err = client.CreateDatabase(ctx, config.Database)
+	err = client.CreateDatabase(ctx, cfg.Database)
 	require.NoError(t, err)
 	err = client.Write(ctx, metrics)
 	require.NoError(t, err)
@@ -616,14 +616,14 @@ func TestHTTP_WriteContentEncodingGzip(t *testing.T) {
 	require.NoError(t, err)
 	metrics := []telegraf.Metric{m}
 
-	config := influxdb.HTTPConfig{
+	cfg := influxdb.HTTPConfig{
 		URL:             u,
 		Database:        "telegraf",
 		ContentEncoding: "gzip",
 		Log:             testutil.Logger{},
 	}
 
-	client, err := influxdb.NewHTTPClient(config)
+	client, err := influxdb.NewHTTPClient(cfg)
 	require.NoError(t, err)
 	err = client.Write(ctx, metrics)
 	require.NoError(t, err)
@@ -730,7 +730,7 @@ func TestHTTP_WriteDatabaseTagWorksOnRetry(t *testing.T) {
 		Host:   ts.Listener.Addr().String(),
 	}
 
-	config := influxdb.HTTPConfig{
+	cfg := influxdb.HTTPConfig{
 		URL:                addr,
 		Database:           "telegraf",
 		DatabaseTag:        "database",
@@ -738,7 +738,7 @@ func TestHTTP_WriteDatabaseTagWorksOnRetry(t *testing.T) {
 		Log:                testutil.Logger{},
 	}
 
-	client, err := influxdb.NewHTTPClient(config)
+	client, err := influxdb.NewHTTPClient(cfg)
 	require.NoError(t, err)
 
 	metrics := []telegraf.Metric{

plugins/parsers/grok/parser_test.go

@@ -795,15 +795,15 @@ func TestShortPatternRegression(t *testing.T) {
 	}
 	require.NoError(t, p.Compile())
 
-	metric, err := p.ParseLine(`Wed Apr 12 13:10:34 PST 2017 42`)
+	m, err := p.ParseLine(`Wed Apr 12 13:10:34 PST 2017 42`)
 	require.NoError(t, err)
-	require.NotNil(t, metric)
+	require.NotNil(t, m)
 
 	require.Equal(t,
 		map[string]interface{}{
 			"value": int64(42),
 		},
-		metric.Fields())
+		m.Fields())
 }
 
 func TestTimezoneEmptyCompileFileAndParse(t *testing.T) {