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

chore: Fix linter findings for makezero (part1) (#12254)

This commit is contained in:
Paweł Żak 2022-11-21 21:07:07 +01:00 committed by GitHub
parent 65200dba2a
commit 743e023f84
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 101 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
plugins/inputs/filecount/filecount.go
View File

@ -237,9 +237,9 @@ func (fc *FileCount) onlyDirectories(directories []string) []string {
}
func (fc *FileCount) getDirs() []string {
dirs := make([]string, len(fc.Directories))
for i, dir := range fc.Directories {
dirs[i] = filepath.Clean(dir)
dirs := make([]string, 0, len(fc.Directories)+1)
for _, dir := range fc.Directories {
dirs = append(dirs, filepath.Clean(dir))
}
if fc.Directory != "" {

4
plugins/inputs/jenkins/jenkins.go
View File

@ -384,8 +384,8 @@ type jobRequest struct {
}
func (jr jobRequest) combined() []string {
path := make([]string, len(jr.parents))
copy(path, jr.parents)
path := make([]string, 0, len(jr.parents)+1)
path = append(path, jr.parents...)
return append(path, jr.name)
}

7
plugins/outputs/sql/sql_test.go
View File

@ -41,10 +41,9 @@ func pwgen(n int) string {
charset := []byte("abcdedfghijklmnopqrstABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
nchars := len(charset)
buffer := make([]byte, n)
for i := range buffer {
buffer[i] = charset[rand.Intn(nchars)]
buffer := make([]byte, 0, n)
for i := 0; i < n; i++ {
buffer = append(buffer, charset[rand.Intn(nchars)])
}
return string(buffer)

5
plugins/outputs/timestream/timestream.go
View File

@ -543,8 +543,7 @@ func partitionRecords(size int, records []types.Record) [][]types.Record {
numberOfPartitions++
}
partitions := make([][]types.Record, numberOfPartitions)
partitions := make([][]types.Record, 0, numberOfPartitions)
for i := 0; i < numberOfPartitions; i++ {
start := size * i
end := size * (i + 1)
@ -552,7 +551,7 @@ func partitionRecords(size int, records []types.Record) [][]types.Record {
end = len(records)
}
partitions[i] = records[start:end]
partitions = append(partitions, records[start:end])
}
return partitions

11
plugins/outputs/warp10/warp10.go
View File

@ -151,16 +151,13 @@ func (w *Warp10) Write(metrics []telegraf.Metric) error {
}
func buildTags(tags []*telegraf.Tag) []string {
tagsString := make([]string, len(tags)+1)
indexSource := 0
for index, tag := range tags {
tagsString := make([]string, 0, len(tags)+1)
for _, tag := range tags {
key := url.QueryEscape(tag.Key)
value := url.QueryEscape(tag.Value)
tagsString[index] = fmt.Sprintf("%s=%s", key, value)
indexSource = index
tagsString = append(tagsString, fmt.Sprintf("%s=%s", key, value))
}
indexSource++
tagsString[indexSource] = "source=telegraf"
tagsString = append(tagsString, "source=telegraf")
sort.Strings(tagsString)
return tagsString
}

110
plugins/parsers/influx/machine_test.go
View File

@ -17,132 +17,118 @@ type TestingHandler struct {
}
func (h *TestingHandler) SetMeasurement(name []byte) error {
n := make([]byte, len(name))
copy(n, name)
n := make([]byte, 0, len(name))
mname := Result{
mName := Result{
Name: Measurement,
Value: n,
Value: append(n, name...),
}
h.results = append(h.results, mname)
h.results = append(h.results, mName)
return nil
}
func (h *TestingHandler) AddTag(key []byte, value []byte) error {
k := make([]byte, len(key))
copy(k, key)
v := make([]byte, len(value))
copy(v, value)
k := make([]byte, 0, len(key))
v := make([]byte, 0, len(value))
tagkey := Result{
tagKey := Result{
Name: TagKey,
Value: k,
Value: append(k, key...),
}
tagvalue := Result{
tagValue := Result{
Name: TagValue,
Value: v,
Value: append(v, value...),
}
h.results = append(h.results, tagkey, tagvalue)
h.results = append(h.results, tagKey, tagValue)
return nil
}
func (h *TestingHandler) AddInt(key []byte, value []byte) error {
k := make([]byte, len(key))
copy(k, key)
v := make([]byte, len(value))
copy(v, value)
k := make([]byte, 0, len(key))
v := make([]byte, 0, len(value))
fieldkey := Result{
fieldKey := Result{
Name: FieldKey,
Value: k,
Value: append(k, key...),
}
fieldvalue := Result{
fieldValue := Result{
Name: FieldInt,
Value: v,
Value: append(v, value...),
}
h.results = append(h.results, fieldkey, fieldvalue)
h.results = append(h.results, fieldKey, fieldValue)
return nil
}
func (h *TestingHandler) AddUint(key []byte, value []byte) error {
k := make([]byte, len(key))
copy(k, key)
v := make([]byte, len(value))
copy(v, value)
k := make([]byte, 0, len(key))
v := make([]byte, 0, len(value))
fieldkey := Result{
fieldKey := Result{
Name: FieldKey,
Value: key,
Value: append(k, key...),
}
fieldvalue := Result{
fieldValue := Result{
Name: FieldUint,
Value: value,
Value: append(v, value...),
}
h.results = append(h.results, fieldkey, fieldvalue)
h.results = append(h.results, fieldKey, fieldValue)
return nil
}
func (h *TestingHandler) AddFloat(key []byte, value []byte) error {
k := make([]byte, len(key))
copy(k, key)
v := make([]byte, len(value))
copy(v, value)
k := make([]byte, 0, len(key))
v := make([]byte, 0, len(value))
fieldkey := Result{
fieldKey := Result{
Name: FieldKey,
Value: k,
Value: append(k, key...),
}
fieldvalue := Result{
fieldValue := Result{
Name: FieldFloat,
Value: v,
Value: append(v, value...),
}
h.results = append(h.results, fieldkey, fieldvalue)
h.results = append(h.results, fieldKey, fieldValue)
return nil
}
func (h *TestingHandler) AddString(key []byte, value []byte) error {
k := make([]byte, len(key))
copy(k, key)
v := make([]byte, len(value))
copy(v, value)
k := make([]byte, 0, len(key))
v := make([]byte, 0, len(value))
fieldkey := Result{
fieldKey := Result{
Name: FieldKey,
Value: k,
Value: append(k, key...),
}
fieldvalue := Result{
fieldValue := Result{
Name: FieldString,
Value: v,
Value: append(v, value...),
}
h.results = append(h.results, fieldkey, fieldvalue)
h.results = append(h.results, fieldKey, fieldValue)
return nil
}
func (h *TestingHandler) AddBool(key []byte, value []byte) error {
k := make([]byte, len(key))
copy(k, key)
v := make([]byte, len(value))
copy(v, value)
k := make([]byte, 0, len(key))
v := make([]byte, 0, len(value))
fieldkey := Result{
fieldKey := Result{
Name: FieldKey,
Value: k,
Value: append(k, key...),
}
fieldvalue := Result{
fieldValue := Result{
Name: FieldBool,
Value: v,
Value: append(v, value...),
}
h.results = append(h.results, fieldkey, fieldvalue)
h.results = append(h.results, fieldKey, fieldValue)
return nil
}
func (h *TestingHandler) SetTimestamp(tm []byte) error {
t := make([]byte, len(tm))
copy(t, tm)
t := make([]byte, 0, len(tm))
timestamp := Result{
Name: Timestamp,
Value: t,
Value: append(t, tm...),
}
h.results = append(h.results, timestamp)
return nil

6
plugins/parsers/json_v2/parser.go
View File

@ -230,14 +230,12 @@ func cartesianProduct(a, b []telegraf.Metric) []telegraf.Metric {
if len(b) == 0 {
return a
}
p := make([]telegraf.Metric, len(a)*len(b))
i := 0
p := make([]telegraf.Metric, 0, len(a)*len(b))
for _, a := range a {
for _, b := range b {
m := a.Copy()
mergeMetric(b, m)
p[i] = m
i++
p = append(p, m)
}
}

6
plugins/parsers/xpath/json_document.go
View File

@ -22,9 +22,9 @@ func (d *jsonDocument) QueryAll(node dataNode, expr string) ([]dataNode, error)
return nil, err
}
nodes := make([]dataNode, len(native))
for i, n := range native {
nodes[i] = n
nodes := make([]dataNode, 0, len(native))
for _, n := range native {
nodes = append(nodes, n)
}
return nodes, nil
}

4
plugins/parsers/xpath/parser.go
View File

@ -499,8 +499,8 @@ func splitLastPathElement(query string) []string {
base = "/"
}
elements := make([]string, 1)
elements[0] = base
elements := make([]string, 0, 3)
elements = append(elements, base)
offset := seperatorIdx
if i := strings.Index(query[offset:], "::"); i >= 0 {

18
plugins/parsers/xpath/protocolbuffer_document.go
View File

@ -6,18 +6,16 @@ import (
"sort"
"strings"
"github.com/influxdata/telegraf"
path "github.com/antchfx/xpath"
"github.com/doclambda/protobufquery"
"github.com/jhump/protoreflect/desc"
"github.com/jhump/protoreflect/desc/protoparse"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protodesc"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/types/dynamicpb"
"github.com/jhump/protoreflect/desc"
"github.com/jhump/protoreflect/desc/protoparse"
path "github.com/antchfx/xpath"
"github.com/doclambda/protobufquery"
"github.com/influxdata/telegraf"
)
type protobufDocument struct {
@ -112,9 +110,9 @@ func (d *protobufDocument) QueryAll(node dataNode, expr string) ([]dataNode, err
return nil, err
}
nodes := make([]dataNode, len(native))
for i, n := range native {
nodes[i] = n
nodes := make([]dataNode, 0, len(native))
for _, n := range native {
nodes = append(nodes, n)
}
return nodes, nil
}

6
plugins/parsers/xpath/xml_document.go
View File

@ -20,9 +20,9 @@ func (d *xmlDocument) QueryAll(node dataNode, expr string) ([]dataNode, error) {
return nil, err
}
nodes := make([]dataNode, len(native))
for i, n := range native {
nodes[i] = n
nodes := make([]dataNode, 0, len(native))
for _, n := range native {
nodes = append(nodes, n)
}
return nodes, nil
}

18
plugins/processors/regex/regex_test.go
View File

@ -273,9 +273,9 @@ func TestMetricNameConversions(t *testing.T) {
for _, test := range tests {
// Copy the inputs as they will be modified by the processor
input := make([]telegraf.Metric, len(inputTemplate))
for i, m := range inputTemplate {
input[i] = m.Copy()
input := make([]telegraf.Metric, 0, len(inputTemplate))
for _, m := range inputTemplate {
input = append(input, m.Copy())
}
t.Run(test.name, func(t *testing.T) {
@ -483,9 +483,9 @@ func TestFieldRenameConversions(t *testing.T) {
for _, test := range tests {
// Copy the inputs as they will be modified by the processor
input := make([]telegraf.Metric, len(inputTemplate))
for i, m := range inputTemplate {
input[i] = m.Copy()
input := make([]telegraf.Metric, 0, len(inputTemplate))
for _, m := range inputTemplate {
input = append(input, m.Copy())
}
t.Run(test.name, func(t *testing.T) {
@ -691,9 +691,9 @@ func TestTagRenameConversions(t *testing.T) {
for _, test := range tests {
// Copy the inputs as they will be modified by the processor
input := make([]telegraf.Metric, len(inputTemplate))
for i, m := range inputTemplate {
input[i] = m.Copy()
input := make([]telegraf.Metric, 0, len(inputTemplate))
for _, m := range inputTemplate {
input = append(input, m.Copy())
}
t.Run(test.name, func(t *testing.T) {

6
plugins/processors/tag_limit/tag_limit.go
View File

@ -52,13 +52,11 @@ func (d *TagLimit) Apply(in ...telegraf.Metric) []telegraf.Metric {
if lenPointTags <= d.Limit {
continue
}
tagsToRemove := make([]string, lenPointTags-d.Limit)
removeIdx := 0
tagsToRemove := make([]string, 0, lenPointTags-d.Limit)
// remove extraneous tags, stop once we're at the limit
for _, t := range pointOriginalTags {
if _, ok := d.keepTags[t.Key]; !ok {
tagsToRemove[removeIdx] = t.Key
removeIdx++
tagsToRemove = append(tagsToRemove, t.Key)
lenPointTags--
}
if lenPointTags <= d.Limit {

10
plugins/serializers/influx/influx.go
View File

@ -102,9 +102,8 @@ func (s *Serializer) Serialize(m telegraf.Metric) ([]byte, error) {
return nil, err
}
out := make([]byte, s.buf.Len())
copy(out, s.buf.Bytes())
return out, nil
out := make([]byte, 0, s.buf.Len())
return append(out, s.buf.Bytes()...), nil
}
// SerializeBatch writes the slice of metrics and returns a byte slice of the
@ -120,9 +119,8 @@ func (s *Serializer) SerializeBatch(metrics []telegraf.Metric) ([]byte, error) {
return nil, err
}
}
out := make([]byte, s.buf.Len())
copy(out, s.buf.Bytes())
return out, nil
out := make([]byte, 0, s.buf.Len())
return append(out, s.buf.Bytes()...), nil
}
func (s *Serializer) Write(w io.Writer, m telegraf.Metric) error {
return s.writeMetric(w, m)

5
plugins/serializers/wavefront/wavefront.go
View File

@ -202,9 +202,8 @@ type buffer []byte
func (b *buffer) Reset() { *b = (*b)[:0] }
func (b *buffer) Copy() []byte {
p := make([]byte, len(*b))
copy(p, *b)
return p
p := make([]byte, 0, len(*b))
return append(p, *b...)
}
func (b *buffer) WriteString(s string) {

12
selfstat/selfstat.go
View File

@ -79,8 +79,7 @@ func RegisterTiming(measurement, field string, tags map[string]string) Stat {
func Metrics() []telegraf.Metric {
registry.mu.Lock()
now := time.Now()
metrics := make([]telegraf.Metric, len(registry.stats))
i := 0
metrics := make([]telegraf.Metric, 0, len(registry.stats))
for _, stats := range registry.stats {
if len(stats) > 0 {
var tags map[string]string
@ -96,8 +95,7 @@ func Metrics() []telegraf.Metric {
j++
}
m := metric.New(name, tags, fields, now)
metrics[i] = m
i++
metrics = append(metrics, m)
}
}
registry.mu.Unlock()
@ -179,11 +177,9 @@ func key(measurement string, tags map[string]string) uint64 {
h := fnv.New64a()
h.Write([]byte(measurement)) //nolint:revive // all Write() methods for hash in fnv.go returns nil err
tmp := make([]string, len(tags))
i := 0
tmp := make([]string, 0, len(tags))
for k, v := range tags {
tmp[i] = k + v
i++
tmp = append(tmp, k+v)
}
sort.Strings(tmp)