CL-Softwares
/
telegraf
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: Fix linter findings for makezero (part2) (#12362)

This commit is contained in:
Paweł Żak 2022-12-09 16:38:37 +01:00 committed by GitHub
parent 0093c53916
commit 4717a03509
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 103 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
plugins/aggregators/quantile/quantile.go
View File

@ -123,8 +123,8 @@ func (q *Quantile) Init() error {
} }
duplicates := make(map[float64]bool) duplicates := make(map[float64]bool)
q.suffixes = make([]string, len(q.Quantiles)) q.suffixes = make([]string, 0, len(q.Quantiles))
for i, qtl := range q.Quantiles { for _, qtl := range q.Quantiles {
if qtl < 0.0 || qtl > 1.0 { if qtl < 0.0 || qtl > 1.0 {
return fmt.Errorf("quantile %v out of range", qtl) return fmt.Errorf("quantile %v out of range", qtl)
} }
@ -132,7 +132,7 @@ func (q *Quantile) Init() error {
return fmt.Errorf("duplicate quantile %v", qtl) return fmt.Errorf("duplicate quantile %v", qtl)
} }
duplicates[qtl] = true duplicates[qtl] = true
q.suffixes[i] = fmt.Sprintf("_%03d", int(qtl*100.0)) q.suffixes = append(q.suffixes, fmt.Sprintf("_%03d", int(qtl*100.0)))
} }
q.Reset() q.Reset()

141
plugins/aggregators/quantile/quantile_test.go
View File

@ -84,9 +84,9 @@ func TestSingleMetricTDigest(t *testing.T) {
), ),
} }
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -101,7 +101,7 @@ func TestSingleMetricTDigest(t *testing.T) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
for _, m := range metrics { for _, m := range metrics {
@ -144,23 +144,22 @@ func TestMultipleMetricsTDigest(t *testing.T) {
), ),
} }
metricsA := make([]telegraf.Metric, 100) metricsA := make([]telegraf.Metric, 0, 100)
metricsB := make([]telegraf.Metric, 100) metricsB := make([]telegraf.Metric, 0, 100)
for i := range metricsA { for i := 0; i < 100; i++ {
metricsA[i] = testutil.MustMetric( metricsA = append(metricsA, testutil.MustMetric(
"test", "test",
map[string]string{"series": "foo"}, map[string]string{"series": "foo"},
map[string]interface{}{"a": int64(i), "b": float64(i), "x1": "string", "x2": true}, map[string]interface{}{"a": int64(i), "b": float64(i), "x1": "string", "x2": true},
time.Now(), time.Now(),
) ))
}
for i := range metricsB { metricsB = append(metricsB, testutil.MustMetric(
metricsB[i] = testutil.MustMetric(
"test", "test",
map[string]string{"series": "bar"}, map[string]string{"series": "bar"},
map[string]interface{}{"a": int64(2 * i), "b": float64(2 * i), "x1": "string", "x2": true}, map[string]interface{}{"a": int64(2 * i), "b": float64(2 * i), "x1": "string", "x2": true},
time.Now(), time.Now(),
) ))
} }
for _, m := range metricsA { for _, m := range metricsA {
@ -217,9 +216,9 @@ func TestSingleMetricExactR7(t *testing.T) {
), ),
} }
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -234,7 +233,7 @@ func TestSingleMetricExactR7(t *testing.T) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
for _, m := range metrics { for _, m := range metrics {
@ -277,23 +276,22 @@ func TestMultipleMetricsExactR7(t *testing.T) {
), ),
} }
metricsA := make([]telegraf.Metric, 100) metricsA := make([]telegraf.Metric, 0, 100)
metricsB := make([]telegraf.Metric, 100) metricsB := make([]telegraf.Metric, 0, 100)
for i := range metricsA { for i := 0; i < 100; i++ {
metricsA[i] = testutil.MustMetric( metricsA = append(metricsA, testutil.MustMetric(
"test", "test",
map[string]string{"series": "foo"}, map[string]string{"series": "foo"},
map[string]interface{}{"a": int64(i), "b": float64(i), "x1": "string", "x2": true}, map[string]interface{}{"a": int64(i), "b": float64(i), "x1": "string", "x2": true},
time.Now(), time.Now(),
) ))
}
for i := range metricsB { metricsB = append(metricsB, testutil.MustMetric(
metricsB[i] = testutil.MustMetric(
"test", "test",
map[string]string{"series": "bar"}, map[string]string{"series": "bar"},
map[string]interface{}{"a": int64(2 * i), "b": float64(2 * i), "x1": "string", "x2": true}, map[string]interface{}{"a": int64(2 * i), "b": float64(2 * i), "x1": "string", "x2": true},
time.Now(), time.Now(),
) ))
} }
for _, m := range metricsA { for _, m := range metricsA {
@ -350,9 +348,9 @@ func TestSingleMetricExactR8(t *testing.T) {
), ),
} }
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -367,7 +365,7 @@ func TestSingleMetricExactR8(t *testing.T) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
for _, m := range metrics { for _, m := range metrics {
@ -410,23 +408,22 @@ func TestMultipleMetricsExactR8(t *testing.T) {
), ),
} }
metricsA := make([]telegraf.Metric, 100) metricsA := make([]telegraf.Metric, 0, 100)
metricsB := make([]telegraf.Metric, 100) metricsB := make([]telegraf.Metric, 0, 100)
for i := range metricsA { for i := 0; i < 100; i++ {
metricsA[i] = testutil.MustMetric( metricsA = append(metricsA, testutil.MustMetric(
"test", "test",
map[string]string{"series": "foo"}, map[string]string{"series": "foo"},
map[string]interface{}{"a": int64(i), "b": float64(i), "x1": "string", "x2": true}, map[string]interface{}{"a": int64(i), "b": float64(i), "x1": "string", "x2": true},
time.Now(), time.Now(),
) ))
}
for i := range metricsB { metricsB = append(metricsB, testutil.MustMetric(
metricsB[i] = testutil.MustMetric(
"test", "test",
map[string]string{"series": "bar"}, map[string]string{"series": "bar"},
map[string]interface{}{"a": int64(2 * i), "b": float64(2 * i), "x1": "string", "x2": true}, map[string]interface{}{"a": int64(2 * i), "b": float64(2 * i), "x1": "string", "x2": true},
time.Now(), time.Now(),
) ))
} }
for _, m := range metricsA { for _, m := range metricsA {
@ -443,9 +440,9 @@ func TestMultipleMetricsExactR8(t *testing.T) {
} }
func BenchmarkDefaultTDigest(b *testing.B) { func BenchmarkDefaultTDigest(b *testing.B) {
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -459,7 +456,7 @@ func BenchmarkDefaultTDigest(b *testing.B) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
q := Quantile{ q := Quantile{
@ -479,9 +476,9 @@ func BenchmarkDefaultTDigest(b *testing.B) {
} }
func BenchmarkDefaultTDigest100Q(b *testing.B) { func BenchmarkDefaultTDigest100Q(b *testing.B) {
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -495,11 +492,11 @@ func BenchmarkDefaultTDigest100Q(b *testing.B) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
quantiles := make([]float64, 100) quantiles := make([]float64, 0, 100)
for i := range quantiles { for i := 0; i < 100; i++ {
quantiles[i] = 0.01 * float64(i) quantiles = append(quantiles, 0.01*float64(i))
} }
q := Quantile{ q := Quantile{
@ -520,9 +517,9 @@ func BenchmarkDefaultTDigest100Q(b *testing.B) {
} }
func BenchmarkDefaultExactR7(b *testing.B) { func BenchmarkDefaultExactR7(b *testing.B) {
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -536,7 +533,7 @@ func BenchmarkDefaultExactR7(b *testing.B) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
q := Quantile{ q := Quantile{
@ -556,9 +553,9 @@ func BenchmarkDefaultExactR7(b *testing.B) {
} }
func BenchmarkDefaultExactR7100Q(b *testing.B) { func BenchmarkDefaultExactR7100Q(b *testing.B) {
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -572,11 +569,11 @@ func BenchmarkDefaultExactR7100Q(b *testing.B) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
quantiles := make([]float64, 100) quantiles := make([]float64, 0, 100)
for i := range quantiles { for i := 0; i < 100; i++ {
quantiles[i] = 0.01 * float64(i) quantiles = append(quantiles, 0.01*float64(i))
} }
q := Quantile{ q := Quantile{
@ -597,9 +594,9 @@ func BenchmarkDefaultExactR7100Q(b *testing.B) {
} }
func BenchmarkDefaultExactR8(b *testing.B) { func BenchmarkDefaultExactR8(b *testing.B) {
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -613,7 +610,7 @@ func BenchmarkDefaultExactR8(b *testing.B) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
q := Quantile{ q := Quantile{
@ -633,9 +630,9 @@ func BenchmarkDefaultExactR8(b *testing.B) {
} }
func BenchmarkDefaultExactR8100Q(b *testing.B) { func BenchmarkDefaultExactR8100Q(b *testing.B) {
metrics := make([]telegraf.Metric, 100) metrics := make([]telegraf.Metric, 0, 100)
for i := range metrics { for i := 0; i < 100; i++ {
metrics[i] = testutil.MustMetric( metrics = append(metrics, testutil.MustMetric(
"test", "test",
map[string]string{"foo": "bar"}, map[string]string{"foo": "bar"},
map[string]interface{}{ map[string]interface{}{
@ -649,11 +646,11 @@ func BenchmarkDefaultExactR8100Q(b *testing.B) {
"x2": true, "x2": true,
}, },
time.Now(), time.Now(),
) ))
} }
quantiles := make([]float64, 100) quantiles := make([]float64, 0, 100)
for i := range quantiles { for i := 0; i < 100; i++ {
quantiles[i] = 0.01 * float64(i) quantiles = append(quantiles, 0.01*float64(i))
} }
q := Quantile{ q := Quantile{

6
plugins/common/jolokia2/client.go
View File

@ -231,9 +231,9 @@ func makeReadResponses(jresponses []jolokiaResponse) []ReadResponse {
rrequest.Attributes = []string{attribute} rrequest.Attributes = []string{attribute}
} else { } else {
attributes, _ := attrValue.([]interface{}) attributes, _ := attrValue.([]interface{})
rrequest.Attributes = make([]string, len(attributes)) rrequest.Attributes = make([]string, 0, len(attributes))
for i, attr := range attributes { for _, attr := range attributes {
rrequest.Attributes[i] = attr.(string) rrequest.Attributes = append(rrequest.Attributes, attr.(string))
} }
} }
} }

6
plugins/common/shim/processor_test.go
View File

@ -22,9 +22,9 @@ func TestProcessorShim(t *testing.T) {
func TestProcessorShimWithLargerThanDefaultScannerBufferSize(t *testing.T) { func TestProcessorShimWithLargerThanDefaultScannerBufferSize(t *testing.T) {
letters := []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ") letters := []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
b := make([]rune, bufio.MaxScanTokenSize*2) b := make([]rune, 0, bufio.MaxScanTokenSize*2)
for i := range b { for i := 0; i < bufio.MaxScanTokenSize*2; i++ {
b[i] = letters[rand.Intn(len(letters))] b = append(b, letters[rand.Intn(len(letters))])
} }
testSendAndReceive(t, "f1", string(b)) testSendAndReceive(t, "f1", string(b))

18
plugins/common/starlark/builtins.go
View File

@ -262,9 +262,9 @@ func dictItems(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err) return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
} }
items := b.Receiver().(starlark.IterableMapping).Items() items := b.Receiver().(starlark.IterableMapping).Items()
res := make([]starlark.Value, len(items)) res := make([]starlark.Value, 0, len(items))
for i, item := range items { for _, item := range items {
res[i] = item // convert [2]starlark.Value to starlark.Value res = append(res, item) // convert [2]starlark.Value to starlark.Value
} }
return starlark.NewList(res), nil return starlark.NewList(res), nil
} }
@ -276,9 +276,9 @@ func dictKeys(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple)
} }
items := b.Receiver().(starlark.IterableMapping).Items() items := b.Receiver().(starlark.IterableMapping).Items()
res := make([]starlark.Value, len(items)) res := make([]starlark.Value, 0, len(items))
for i, item := range items { for _, item := range items {
res[i] = item[0] res = append(res, item[0])
} }
return starlark.NewList(res), nil return starlark.NewList(res), nil
} }
@ -289,9 +289,9 @@ func dictValues(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tupl
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err) return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
} }
items := b.Receiver().(starlark.IterableMapping).Items() items := b.Receiver().(starlark.IterableMapping).Items()
res := make([]starlark.Value, len(items)) res := make([]starlark.Value, 0, len(items))
for i, item := range items { for _, item := range items {
res[i] = item[1] res = append(res, item[1])
} }
return starlark.NewList(res), nil return starlark.NewList(res), nil
} }

4
plugins/common/starlark/field_dict.go
View File

@ -218,13 +218,13 @@ func asStarlarkValue(value interface{}) (starlark.Value, error) {
switch v.Kind() { switch v.Kind() {
case reflect.Slice: case reflect.Slice:
length := v.Len() length := v.Len()
array := make([]starlark.Value, length) array := make([]starlark.Value, 0, length)
for i := 0; i < length; i++ { for i := 0; i < length; i++ {
sVal, err := asStarlarkValue(v.Index(i).Interface()) sVal, err := asStarlarkValue(v.Index(i).Interface())
if err != nil { if err != nil {
return starlark.None, err return starlark.None, err
} }
array[i] = sVal array = append(array, sVal)
} }
return starlark.NewList(array), nil return starlark.NewList(array), nil
case reflect.Map: case reflect.Map:

8
plugins/inputs/azure_monitor/azure_monitor.go
View File

@ -126,16 +126,16 @@ func (am *AzureMonitor) Gather(acc telegraf.Accumulator) error {
} }
func (am *AzureMonitor) setReceiver() error { func (am *AzureMonitor) setReceiver() error {
var resourceTargets []*receiver.ResourceTarget resourceTargets := make([]*receiver.ResourceTarget, 0, len(am.ResourceTargets))
var resourceGroupTargets []*receiver.ResourceGroupTarget resourceGroupTargets := make([]*receiver.ResourceGroupTarget, 0, len(am.ResourceGroupTargets))
var subscriptionTargets []*receiver.Resource subscriptionTargets := make([]*receiver.Resource, 0, len(am.SubscriptionTargets))
for _, target := range am.ResourceTargets { for _, target := range am.ResourceTargets {
resourceTargets = append(resourceTargets, receiver.NewResourceTarget(target.ResourceID, target.Metrics, target.Aggregations)) resourceTargets = append(resourceTargets, receiver.NewResourceTarget(target.ResourceID, target.Metrics, target.Aggregations))
} }
for _, target := range am.ResourceGroupTargets { for _, target := range am.ResourceGroupTargets {
var resources []*receiver.Resource resources := make([]*receiver.Resource, 0, len(target.Resources))
for _, resource := range target.Resources { for _, resource := range target.Resources {
resources = append(resources, receiver.NewResource(resource.ResourceType, resource.Metrics, resource.Aggregations)) resources = append(resources, receiver.NewResource(resource.ResourceType, resource.Metrics, resource.Aggregations))
} }

2
plugins/inputs/azure_monitor/azure_monitor_test.go
View File

@ -975,7 +975,7 @@ func TestGather_Success(t *testing.T) {
am.Log = testutil.Logger{} am.Log = testutil.Logger{}
am.azureManager = &mockAzureClientsManager{} am.azureManager = &mockAzureClientsManager{}
var resourceTargets []*receiver.ResourceTarget resourceTargets := make([]*receiver.ResourceTarget, 0, len(am.ResourceTargets))
for _, target := range am.ResourceTargets { for _, target := range am.ResourceTargets {
resourceTargets = append(resourceTargets, receiver.NewResourceTarget(target.ResourceID, target.Metrics, target.Aggregations)) resourceTargets = append(resourceTargets, receiver.NewResourceTarget(target.ResourceID, target.Metrics, target.Aggregations))
} }

8
plugins/inputs/cloudwatch/cloudwatch.go
View File

@ -241,12 +241,12 @@ func getFilteredMetrics(c *CloudWatch) ([]filteredMetric, error) {
for _, m := range c.Metrics { for _, m := range c.Metrics {
metrics := []types.Metric{} metrics := []types.Metric{}
if !hasWildcard(m.Dimensions) { if !hasWildcard(m.Dimensions) {
dimensions := make([]types.Dimension, len(m.Dimensions)) dimensions := make([]types.Dimension, 0, len(m.Dimensions))
for k, d := range m.Dimensions { for _, d := range m.Dimensions {
dimensions[k] = types.Dimension{ dimensions = append(dimensions, types.Dimension{
Name: aws.String(d.Name), Name: aws.String(d.Name),
Value: aws.String(d.Value), Value: aws.String(d.Value),
} })
} }
for _, name := range m.MetricNames { for _, name := range m.MetricNames {
for _, namespace := range c.Namespaces { for _, namespace := range c.Namespaces {

7
plugins/inputs/redis_sentinel/redis_sentinel.go
View File

@ -216,21 +216,20 @@ func (client *RedisSentinelClient) gatherInfoStats(acc telegraf.Accumulator) err
} }
func (client *RedisSentinelClient) gatherMasterStats(acc telegraf.Accumulator) ([]string, error) { func (client *RedisSentinelClient) gatherMasterStats(acc telegraf.Accumulator) ([]string, error) {
var masterNames []string
mastersCmd := redis.NewSliceCmd("sentinel", "masters") mastersCmd := redis.NewSliceCmd("sentinel", "masters")
if err := client.sentinel.Process(mastersCmd); err != nil { if err := client.sentinel.Process(mastersCmd); err != nil {
return masterNames, err return nil, err
} }
masters, err := mastersCmd.Result() masters, err := mastersCmd.Result()
if err != nil { if err != nil {
return masterNames, err return nil, err
} }
// Break out of the loop if one of the items comes out malformed // Break out of the loop if one of the items comes out malformed
// It's safe to assume that if we fail parsing one item that the rest will fail too // It's safe to assume that if we fail parsing one item that the rest will fail too
// This is because we are iterating over a single server response // This is because we are iterating over a single server response
masterNames := make([]string, 0, len(masters))
for _, master := range masters { for _, master := range masters {
master, ok := master.([]interface{}) master, ok := master.([]interface{})
if !ok { if !ok {

4
plugins/outputs/graylog/graylog.go
View File

@ -356,8 +356,8 @@ func (g *Graylog) Connect() error {
servers := strings.Join(unconnected, ",") servers := strings.Join(unconnected, ",")
return fmt.Errorf("connect: connection failed for %s", servers) return fmt.Errorf("connect: connection failed for %s", servers)
} }
var writers []io.Writer writers := make([]io.Writer, 0, len(gelfs))
var closers []io.WriteCloser closers := make([]io.WriteCloser, 0, len(gelfs))
for _, w := range gelfs { for _, w := range gelfs {
writers = append(writers, w) writers = append(writers, w)
closers = append(closers, w) closers = append(closers, w)