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

chore: Fix linter findings for errorlint (part2) (#12702) 

Co-authored-by: Pawel Zak <Pawel Zak>
This commit is contained in:
Paweł Żak 2023-02-22 12:08:46 +01:00 committed by GitHub
parent 97f8a596e2
commit 4201f24020
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
46 changed files with 164 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -115,7 +115,7 @@ func (q *Quantile) Init() error {
return fmt.Errorf("unknown algorithm type %q", q.AlgorithmType)
}
if _, err := q.newAlgorithm(q.Compression); err != nil {
return fmt.Errorf("cannot create %q algorithm: %v", q.AlgorithmType, err)
return fmt.Errorf("cannot create %q algorithm: %w", q.AlgorithmType, err)
}
if len(q.Quantiles) == 0 {

8
plugins/common/encoding/decoder_reader.go
View File

@ -133,7 +133,7 @@ func (r *Reader) Read(p []byte) (int, error) {
if r.src0 != r.src1 || r.err != nil {
var err error
r.dst0 = 0
r.dst1, n, err = r.t.Transform(r.dst, r.src[r.src0:r.src1], r.err == io.EOF)
r.dst1, n, err = r.t.Transform(r.dst, r.src[r.src0:r.src1], errors.Is(r.err, io.EOF))
r.src0 += n
switch {
@ -145,16 +145,16 @@ func (r *Reader) Read(p []byte) (int, error) {
// cannot read more bytes into src.
r.transformComplete = r.err != nil
continue
case err == ErrShortDst && (r.dst1 != 0 || n != 0):
case errors.Is(err, ErrShortDst) && (r.dst1 != 0 || n != 0):
// Make room in dst by copying out, and try again.
continue
case err == ErrShortSrc && r.src1-r.src0 != len(r.src) && r.err == nil:
case errors.Is(err, ErrShortSrc) && r.src1-r.src0 != len(r.src) && r.err == nil:
// Read more bytes into src via the code below, and try again.
default:
r.transformComplete = true
// The reader error (r.err) takes precedence over the
// transformer error (err) unless r.err is nil or io.EOF.
if r.err == nil || r.err == io.EOF {
if r.err == nil || errors.Is(r.err, io.EOF) {
r.err = err
}
continue

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

@ -160,7 +160,7 @@ func (c *Client) read(requests []ReadRequest) ([]ReadResponse, error) {
var jResponses []jolokiaResponse
if err = json.Unmarshal(responseBody, &jResponses); err != nil {
return nil, fmt.Errorf("decoding JSON response: %s: %s", err, responseBody)
return nil, fmt.Errorf("decoding JSON response: %w: %s", err, responseBody)
}
return makeReadResponses(jResponses), nil

3
plugins/common/opcua/client.go
View File

@ -9,6 +9,7 @@ import (
"github.com/gopcua/opcua"
"github.com/gopcua/opcua/ua"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/config"
)
@ -184,7 +185,7 @@ func (o *OpcUAClient) Connect() error {
defer cancel()
if err := o.Client.Connect(ctx); err != nil {
o.State = Disconnected
return fmt.Errorf("error in Client Connection: %s", err)
return fmt.Errorf("error in Client Connection: %w", err)
}
o.State = Connected

28
plugins/common/opcua/opcua_util.go
View File

@ -47,7 +47,7 @@ func generateCert(host string, rsaBits int, certFile, keyFile string, dur time.D
priv, err := rsa.GenerateKey(rand.Reader, rsaBits)
if err != nil {
return "", "", fmt.Errorf("failed to generate private key: %s", err)
return "", "", fmt.Errorf("failed to generate private key: %w", err)
}
notBefore := time.Now()
@ -56,7 +56,7 @@ func generateCert(host string, rsaBits int, certFile, keyFile string, dur time.D
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
if err != nil {
return "", "", fmt.Errorf("failed to generate serial number: %s", err)
return "", "", fmt.Errorf("failed to generate serial number: %w", err)
}
template := x509.Certificate{
@ -87,33 +87,33 @@ func generateCert(host string, rsaBits int, certFile, keyFile string, dur time.D
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey(priv), priv)
if err != nil {
return "", "", fmt.Errorf("failed to create certificate: %s", err)
return "", "", fmt.Errorf("failed to create certificate: %w", err)
}
certOut, err := os.Create(certFile)
if err != nil {
return "", "", fmt.Errorf("failed to open %s for writing: %s", certFile, err)
return "", "", fmt.Errorf("failed to open %s for writing: %w", certFile, err)
}
if err := pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
return "", "", fmt.Errorf("failed to write data to %s: %s", certFile, err)
return "", "", fmt.Errorf("failed to write data to %s: %w", certFile, err)
}
if err := certOut.Close(); err != nil {
return "", "", fmt.Errorf("error closing %s: %s", certFile, err)
return "", "", fmt.Errorf("error closing %s: %w", certFile, err)
}
keyOut, err := os.OpenFile(keyFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
return "", "", fmt.Errorf("failed to open %s for writing: %s", keyFile, err)
return "", "", fmt.Errorf("failed to open %s for writing: %w", keyFile, err)
}
keyBlock, err := pemBlockForKey(priv)
if err != nil {
return "", "", fmt.Errorf("error generating block: %v", err)
return "", "", fmt.Errorf("error generating block: %w", err)
}
if err := pem.Encode(keyOut, keyBlock); err != nil {
return "", "", fmt.Errorf("failed to write data to %s: %s", keyFile, err)
return "", "", fmt.Errorf("failed to write data to %s: %w", keyFile, err)
}
if err := keyOut.Close(); err != nil {
return "", "", fmt.Errorf("error closing %s: %s", keyFile, err)
return "", "", fmt.Errorf("error closing %s: %w", keyFile, err)
}
return certFile, keyFile, nil
@ -137,7 +137,7 @@ func pemBlockForKey(priv interface{}) (*pem.Block, error) {
case *ecdsa.PrivateKey:
b, err := x509.MarshalECPrivateKey(k)
if err != nil {
return nil, fmt.Errorf("unable to marshal ECDSA private key: %v", err)
return nil, fmt.Errorf("unable to marshal ECDSA private key: %w", err)
}
return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b}, nil
default:
@ -282,7 +282,7 @@ func (o *OpcUAClient) generateClientOpts(endpoints []*ua.EndpointDescription) ([
// Check that the selected endpoint is a valid combo
err = validateEndpointConfig(endpoints, secPolicy, secMode, authMode)
if err != nil {
return nil, fmt.Errorf("error validating input: %s", err)
return nil, fmt.Errorf("error validating input: %w", err)
}
opts = append(opts, opcua.SecurityFromEndpoint(serverEndpoint, authMode))
@ -304,13 +304,13 @@ func (o *OpcUAClient) generateAuth(a string, cert []byte, un, pw string) (ua.Use
if un == "" {
if err != nil {
return 0, nil, fmt.Errorf("error reading the username input: %s", err)
return 0, nil, fmt.Errorf("error reading the username input: %w", err)
}
}
if pw == "" {
if err != nil {
return 0, nil, fmt.Errorf("error reading the password input: %s", err)
return 0, nil, fmt.Errorf("error reading the password input: %w", err)
}
}

4
plugins/common/shim/goshim.go
View File

@ -110,12 +110,12 @@ func (s *Shim) writeProcessedMetrics() error {
}
b, err := serializer.Serialize(m)
if err != nil {
return fmt.Errorf("failed to serialize metric: %s", err)
return fmt.Errorf("failed to serialize metric: %w", err)
}
// Write this to stdout
_, err = fmt.Fprint(s.stdout, string(b))
if err != nil {
return fmt.Errorf("failed to write metric: %s", err)
return fmt.Errorf("failed to write metric: %w", err)
}
}
}

4
plugins/common/shim/input.go
View File

@ -17,7 +17,7 @@ func (s *Shim) AddInput(input telegraf.Input) error {
if p, ok := input.(telegraf.Initializer); ok {
err := p.Init()
if err != nil {
return fmt.Errorf("failed to init input: %s", err)
return fmt.Errorf("failed to init input: %w", err)
}
}
@ -38,7 +38,7 @@ func (s *Shim) RunInput(pollInterval time.Duration) error {
if serviceInput, ok := s.Input.(telegraf.ServiceInput); ok {
if err := serviceInput.Start(acc); err != nil {
return fmt.Errorf("failed to start input: %s", err)
return fmt.Errorf("failed to start input: %w", err)
}
}
s.gatherPromptCh = make(chan empty, 1)

2
plugins/common/shim/output.go
View File

@ -14,7 +14,7 @@ func (s *Shim) AddOutput(output telegraf.Output) error {
if p, ok := output.(telegraf.Initializer); ok {
err := p.Init()
if err != nil {
return fmt.Errorf("failed to init input: %s", err)
return fmt.Errorf("failed to init input: %w", err)
}
}

8
plugins/common/shim/processor.go
View File

@ -1,6 +1,7 @@
package shim
import (
"errors"
"fmt"
"sync"
"time"
@ -24,7 +25,7 @@ func (s *Shim) AddStreamingProcessor(processor telegraf.StreamingProcessor) erro
if p, ok := processor.(telegraf.Initializer); ok {
err := p.Init()
if err != nil {
return fmt.Errorf("failed to init input: %s", err)
return fmt.Errorf("failed to init input: %w", err)
}
}
@ -55,10 +56,11 @@ func (s *Shim) RunProcessor() error {
for {
m, err := parser.Next()
if err != nil {
if err == influx.EOF {
if errors.Is(err, influx.EOF) {
break // stream ended
}
if parseErr, isParseError := err.(*influx.ParseError); isParseError {
var parseErr *influx.ParseError
if errors.As(err, &parseErr) {
fmt.Fprintf(s.stderr, "Failed to parse metric: %s\b", parseErr)
continue
}

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

@ -101,7 +101,7 @@ func builtinAttrNames(methods map[string]builtinMethod) []string {
// https://github.com/google/starlark-go/blob/master/doc/spec.md#dict·clear
func dictClear(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
type HasClear interface {
@ -114,14 +114,14 @@ func dictClear(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple
func dictPop(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
var k, d starlark.Value
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 1, &k, &d); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
type HasDelete interface {
Delete(k starlark.Value) (starlark.Value, bool, error)
}
if v, found, err := b.Receiver().(HasDelete).Delete(k); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err) // dict is frozen or key is unhashable
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err) // dict is frozen or key is unhashable
} else if found {
return v, nil
} else if d != nil {
@ -133,7 +133,7 @@ func dictPop(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple)
// https://github.com/google/starlark-go/blob/master/doc/spec.md#dict·popitem
func dictPopitem(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
type HasPopItem interface {
@ -146,10 +146,10 @@ func dictPopitem(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tup
func dictGet(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
var key, dflt starlark.Value
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 1, &key, &dflt); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
if v, ok, err := b.Receiver().(starlark.Mapping).Get(key); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
} else if ok {
return v, nil
} else if dflt != nil {
@ -162,18 +162,18 @@ func dictGet(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple)
func dictSetdefault(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
var key, dflt starlark.Value = nil, starlark.None
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 1, &key, &dflt); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
recv := b.Receiver().(starlark.HasSetKey)
v, found, err := recv.Get(key)
if err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
if !found {
v = dflt
if err := recv.SetKey(key, dflt); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
}
return v, nil
@ -259,7 +259,7 @@ func dictUpdate(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tupl
// https://github.com/google/starlark-go/blob/master/doc/spec.md#dict·items
func dictItems(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
items := b.Receiver().(starlark.IterableMapping).Items()
res := make([]starlark.Value, 0, len(items))
@ -272,7 +272,7 @@ func dictItems(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple
// https://github.com/google/starlark-go/blob/master/doc/spec.md#dict·keys
func dictKeys(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
items := b.Receiver().(starlark.IterableMapping).Items()
@ -286,7 +286,7 @@ func dictKeys(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple)
// https://github.com/google/starlark-go/blob/master/doc/spec.md#dict·update
func dictValues(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
items := b.Receiver().(starlark.IterableMapping).Items()
res := make([]starlark.Value, 0, len(items))

5
plugins/common/starlark/logging.go
View File

@ -4,9 +4,10 @@ import (
"errors"
"fmt"
"github.com/influxdata/telegraf"
"go.starlark.net/starlark"
"go.starlark.net/starlarkstruct"
"github.com/influxdata/telegraf"
)
// Builds a module that defines all the supported logging functions which will log using the provided logger
@ -29,7 +30,7 @@ func LogModule(logger telegraf.Logger) *starlarkstruct.Module {
func log(b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple, logger telegraf.Logger) (starlark.Value, error) {
var msg starlark.String
if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 1, &msg); err != nil {
return starlark.None, fmt.Errorf("%s: %v", b.Name(), err)
return starlark.None, fmt.Errorf("%s: %w", b.Name(), err)
}
switch b.Name() {
case "log.debug":

8
plugins/common/starlark/starlark.go
View File

@ -5,12 +5,13 @@ import (
"fmt"
"strings"
"github.com/influxdata/telegraf"
"go.starlark.net/lib/json"
"go.starlark.net/lib/math"
"go.starlark.net/lib/time"
"go.starlark.net/resolve"
"go.starlark.net/starlark"
"github.com/influxdata/telegraf"
)
type Common struct {
@ -108,7 +109,7 @@ func (s *Common) addConstants(builtins *starlark.StringDict) error {
for key, val := range s.Constants {
sVal, err := asStarlarkValue(val)
if err != nil {
return fmt.Errorf("converting type %T failed: %v", val, err)
return fmt.Errorf("converting type %T failed: %w", val, err)
}
(*builtins)[key] = sVal
}
@ -138,7 +139,8 @@ func (s *Common) Call(name string) (starlark.Value, error) {
}
func (s *Common) LogError(err error) {
if evalErr, ok := err.(*starlark.EvalError); ok {
var evalErr *starlark.EvalError
if errors.As(err, &evalErr) {
for _, line := range strings.Split(evalErr.Backtrace(), "\n") {
s.Log.Error(line)
}

21
plugins/common/tls/config.go
View File

@ -149,7 +149,7 @@ func (c *ServerConfig) TLSConfig() (*tls.Config, error) {
cipherSuites, err := ParseCiphers(c.TLSCipherSuites)
if err != nil {
return nil, fmt.Errorf(
"could not parse server cipher suites %s: %v", strings.Join(c.TLSCipherSuites, ","), err)
"could not parse server cipher suites %s: %w", strings.Join(c.TLSCipherSuites, ","), err)
}
tlsConfig.CipherSuites = cipherSuites
}
@ -158,7 +158,7 @@ func (c *ServerConfig) TLSConfig() (*tls.Config, error) {
version, err := ParseTLSVersion(c.TLSMaxVersion)
if err != nil {
return nil, fmt.Errorf(
"could not parse tls max version %q: %v", c.TLSMaxVersion, err)
"could not parse tls max version %q: %w", c.TLSMaxVersion, err)
}
tlsConfig.MaxVersion = version
}
@ -171,15 +171,13 @@ func (c *ServerConfig) TLSConfig() (*tls.Config, error) {
if c.TLSMinVersion != "" {
version, err := ParseTLSVersion(c.TLSMinVersion)
if err != nil {
return nil, fmt.Errorf(
"could not parse tls min version %q: %v", c.TLSMinVersion, err)
return nil, fmt.Errorf("could not parse tls min version %q: %w", c.TLSMinVersion, err)
}
tlsConfig.MinVersion = version
}
if tlsConfig.MinVersion != 0 && tlsConfig.MaxVersion != 0 && tlsConfig.MinVersion > tlsConfig.MaxVersion {
return nil, fmt.Errorf(
"tls min version %q can't be greater than tls max version %q", tlsConfig.MinVersion, tlsConfig.MaxVersion)
return nil, fmt.Errorf("tls min version %q can't be greater than tls max version %q", tlsConfig.MinVersion, tlsConfig.MaxVersion)
}
// Since clientAuth is tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert
@ -196,12 +194,10 @@ func makeCertPool(certFiles []string) (*x509.CertPool, error) {
for _, certFile := range certFiles {
pem, err := os.ReadFile(certFile)
if err != nil {
return nil, fmt.Errorf(
"could not read certificate %q: %v", certFile, err)
return nil, fmt.Errorf("could not read certificate %q: %w", certFile, err)
}
if !pool.AppendCertsFromPEM(pem) {
return nil, fmt.Errorf(
"could not parse any PEM certificates %q: %v", certFile, err)
return nil, fmt.Errorf("could not parse any PEM certificates %q: %w", certFile, err)
}
}
return pool, nil
@ -210,8 +206,7 @@ func makeCertPool(certFiles []string) (*x509.CertPool, error) {
func loadCertificate(config *tls.Config, certFile, keyFile string) error {
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return fmt.Errorf(
"could not load keypair %s:%s: %v", certFile, keyFile, err)
return fmt.Errorf("could not load keypair %s:%s: %w", certFile, keyFile, err)
}
config.Certificates = []tls.Certificate{cert}
@ -223,7 +218,7 @@ func (c *ServerConfig) verifyPeerCertificate(rawCerts [][]byte, _ [][]*x509.Cert
// Let's review the client certificate.
cert, err := x509.ParseCertificate(rawCerts[0])
if err != nil {
return fmt.Errorf("could not validate peer certificate: %v", err)
return fmt.Errorf("could not validate peer certificate: %w", err)
}
for _, name := range cert.DNSNames {

2
plugins/parsers/collectd/parser.go
View File

@ -68,7 +68,7 @@ func (p *Parser) Init() error {
func (p *Parser) Parse(buf []byte) ([]telegraf.Metric, error) {
valueLists, err := network.Parse(buf, p.popts)
if err != nil {
return nil, fmt.Errorf("collectd parser error: %s", err)
return nil, fmt.Errorf("collectd parser error: %w", err)
}
metrics := []telegraf.Metric{}

8
plugins/parsers/csv/parser.go
View File

@ -163,7 +163,7 @@ func (p *Parser) Init() error {
}
if err := p.initializeMetadataSeparators(); err != nil {
return fmt.Errorf("initializing separators failed: %v", err)
return fmt.Errorf("initializing separators failed: %w", err)
}
if p.TimeFunc == nil {
@ -393,17 +393,17 @@ outer:
case "int":
val, err = strconv.ParseInt(value, 10, 64)
if err != nil {
return nil, fmt.Errorf("column type: parse int error %s", err)
return nil, fmt.Errorf("column type: parse int error %w", err)
}
case "float":
val, err = strconv.ParseFloat(value, 64)
if err != nil {
return nil, fmt.Errorf("column type: parse float error %s", err)
return nil, fmt.Errorf("column type: parse float error %w", err)
}
case "bool":
val, err = strconv.ParseBool(value)
if err != nil {
return nil, fmt.Errorf("column type: parse bool error %s", err)
return nil, fmt.Errorf("column type: parse bool error %w", err)
}
default:
val = value

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

@ -128,7 +128,7 @@ func (p *Parser) parseTime(buf []byte) (time.Time, error) {
}
t, err := time.Parse(timeFormat, timeString)
if err != nil {
return time.Time{}, fmt.Errorf("time %s cannot be parsed with format %s, %s", timeString, timeFormat, err)
return time.Time{}, fmt.Errorf("time %s cannot be parsed with format %s, %w", timeString, timeFormat, err)
}
return t.UTC(), nil
}
@ -154,7 +154,7 @@ func (p *Parser) unmarshalMetrics(buf []byte) (map[string]interface{}, error) {
var jsonOut map[string]interface{}
err := json.Unmarshal(registryBytes, &jsonOut)
if err != nil {
err = fmt.Errorf("unable to parse dropwizard metric registry from JSON document, %s", err)
err = fmt.Errorf("unable to parse dropwizard metric registry from JSON document, %w", err)
return nil, err
}
return jsonOut, nil

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

@ -108,7 +108,7 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
// Parse value.
v, err := strconv.ParseFloat(fields[1], 64)
if err != nil {
return nil, fmt.Errorf(`field "%s" value: %s`, fields[0], err)
return nil, fmt.Errorf(`field "%s" value: %w`, fields[0], err)
}
fieldValues := map[string]interface{}{}
@ -125,7 +125,7 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
// Parse timestamp.
unixTime, err := strconv.ParseFloat(fields[2], 64)
if err != nil {
return nil, fmt.Errorf(`field "%s" time: %s`, fields[0], err)
return nil, fmt.Errorf(`field "%s" time: %w`, fields[0], err)
}
// -1 is a special value that gets converted to current UTC time

20
plugins/parsers/influx/handler.go
View File

@ -62,8 +62,9 @@ func (h *MetricHandler) AddInt(key []byte, value []byte) error {
fk := unescape(key)
fv, err := parseIntBytes(bytes.TrimSuffix(value, []byte("i")), 10, 64)
if err != nil {
if numerr, ok := err.(*strconv.NumError); ok {
return numerr.Err
var numErr *strconv.NumError
if errors.As(err, &numErr) {
return numErr.Err
}
return err
}
@ -75,8 +76,9 @@ func (h *MetricHandler) AddUint(key []byte, value []byte) error {
fk := unescape(key)
fv, err := parseUintBytes(bytes.TrimSuffix(value, []byte("u")), 10, 64)
if err != nil {
if numerr, ok := err.(*strconv.NumError); ok {
return numerr.Err
var numErr *strconv.NumError
if errors.As(err, &numErr) {
return numErr.Err
}
return err
}
@ -88,8 +90,9 @@ func (h *MetricHandler) AddFloat(key []byte, value []byte) error {
fk := unescape(key)
fv, err := parseFloatBytes(value, 64)
if err != nil {
if numerr, ok := err.(*strconv.NumError); ok {
return numerr.Err
var numErr *strconv.NumError
if errors.As(err, &numErr) {
return numErr.Err
}
return err
}
@ -117,8 +120,9 @@ func (h *MetricHandler) AddBool(key []byte, value []byte) error {
func (h *MetricHandler) SetTimestamp(tm []byte) error {
v, err := parseIntBytes(tm, 10, 64)
if err != nil {
if numerr, ok := err.(*strconv.NumError); ok {
return numerr.Err
var numErr *strconv.NumError
if errors.As(err, &numErr) {
return numErr.Err
}
return err
}

9
plugins/parsers/influx/influx_upstream/parser.go
View File

@ -8,6 +8,7 @@ import (
"time"
"github.com/influxdata/line-protocol/v2/lineprotocol"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/metric"
"github.com/influxdata/telegraf/plugins/parsers"
@ -88,13 +89,13 @@ func (e *ParseError) Error() string {
// convertToParseError attempts to convert a lineprotocol.DecodeError to a ParseError
func convertToParseError(input []byte, rawErr error) error {
err, ok := rawErr.(*lineprotocol.DecodeError)
if !ok {
var decErr *lineprotocol.DecodeError
if !errors.As(rawErr, &decErr) {
return rawErr
}
return &ParseError{
DecodeError: err,
DecodeError: decErr,
buf: string(input),
}
}
@ -249,7 +250,7 @@ func (sp *StreamParser) SetTimePrecision(u time.Duration) error {
// function if it returns ParseError to get the next metric or error.
func (sp *StreamParser) Next() (telegraf.Metric, error) {
if !sp.decoder.Next() {
if err := sp.decoder.Err(); err != nil && err != sp.lastError {
if err := sp.decoder.Err(); err != nil && !errors.Is(err, sp.lastError) {
sp.lastError = err
return nil, err
}

4
plugins/parsers/influx/influx_upstream/parser_test.go
View File

@ -659,7 +659,7 @@ func TestStreamParser(t *testing.T) {
for {
m, err := parser.Next()
if err != nil {
if err == ErrEOF {
if errors.Is(err, ErrEOF) {
break
}
require.Equal(t, tt.err.Error(), err.Error())
@ -849,7 +849,7 @@ func TestStreamParserErrorString(t *testing.T) {
var errs []error
for i := 0; i < 20; i++ {
_, err := parser.Next()
if err == ErrEOF {
if errors.Is(err, ErrEOF) {
break
}

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

@ -1710,7 +1710,7 @@ func TestMachine(t *testing.T) {
for i := 0; i < 20; i++ {
err := fsm.Next()
if err != nil && err == influx.EOF {
if err != nil && errors.Is(err, influx.EOF) {
break
}
handler.Result(err)
@ -2138,7 +2138,7 @@ func TestHandlerErrorRecovery(t *testing.T) {
for i := 0; i < 20; i++ {
err := fsm.Next()
if err != nil && err == influx.EOF {
if err != nil && errors.Is(err, influx.EOF) {
break
}
tt.handler.Result(err)
@ -2177,7 +2177,7 @@ func TestStreamMachine(t *testing.T) {
// isn't terminated.
for i := 0; i < 20; i++ {
err := fsm.Next()
if err != nil && err == influx.EOF {
if err != nil && errors.Is(err, influx.EOF) {
break
}
handler.Result(err)

7
plugins/parsers/influx/parser.go
View File

@ -85,7 +85,7 @@ func (p *Parser) Parse(input []byte) ([]telegraf.Metric, error) {
for {
err := p.machine.Next()
if err == EOF {
if errors.Is(err, EOF) {
break
}
@ -203,11 +203,12 @@ func (sp *StreamParser) SetTimePrecision(u time.Duration) {
// function if it returns ParseError to get the next metric or error.
func (sp *StreamParser) Next() (telegraf.Metric, error) {
err := sp.machine.Next()
if err == EOF {
if errors.Is(err, EOF) {
return nil, err
}
if e, ok := err.(*readErr); ok {
var e *readErr
if errors.As(err, &e) {
return nil, e.Err
}

4
plugins/parsers/influx/parser_test.go
View File

@ -629,7 +629,7 @@ func TestStreamParser(t *testing.T) {
for {
m, err := parser.Next()
if err != nil {
if err == EOF {
if errors.Is(err, EOF) {
break
}
require.Equal(t, tt.err, err)
@ -816,7 +816,7 @@ func TestStreamParserErrorString(t *testing.T) {
var errs []error
for i := 0; i < 20; i++ {
_, err := parser.Next()
if err == EOF {
if errors.Is(err, EOF) {
break
}

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

@ -161,12 +161,12 @@ func (p *Parser) Init() error {
p.stringFilter, err = filter.Compile(p.StringFields)
if err != nil {
return fmt.Errorf("compiling string-fields filter failed: %v", err)
return fmt.Errorf("compiling string-fields filter failed: %w", err)
}
p.tagFilter, err = filter.Compile(p.TagKeys)
if err != nil {
return fmt.Errorf("compiling tag-key filter failed: %v", err)
return fmt.Errorf("compiling tag-key filter failed: %w", err)
}
return nil

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

@ -75,7 +75,7 @@ func (p *Parser) Parse(input []byte) ([]telegraf.Metric, error) {
body, _ := utfbom.Skip(reader)
input, err := io.ReadAll(body)
if err != nil {
return nil, fmt.Errorf("unable to read body after BOM removal: %v", err)
return nil, fmt.Errorf("unable to read body after BOM removal: %w", err)
}
// Only valid JSON is supported
@ -102,7 +102,7 @@ func (p *Parser) Parse(input []byte) ([]telegraf.Metric, error) {
if result.Type == gjson.Null {
p.Log.Debugf("Message: %s", input)
return nil, fmt.Errorf("The timestamp path %s returned NULL", c.TimestampPath)
return nil, fmt.Errorf("the timestamp path %s returned NULL", c.TimestampPath)
}
if !result.IsArray() && !result.IsObject() {
if c.TimestampFormat == "" {
@ -586,25 +586,25 @@ func (p *Parser) convertType(input gjson.Result, desiredType string, name string
case "uint":
r, err := strconv.ParseUint(inputType, 10, 64)
if err != nil {
return nil, fmt.Errorf("Unable to convert field '%s' to type uint: %v", name, err)
return nil, fmt.Errorf("unable to convert field '%s' to type uint: %w", name, err)
}
return r, nil
case "int":
r, err := strconv.ParseInt(inputType, 10, 64)
if err != nil {
return nil, fmt.Errorf("Unable to convert field '%s' to type int: %v", name, err)
return nil, fmt.Errorf("unable to convert field '%s' to type int: %w", name, err)
}
return r, nil
case "float":
r, err := strconv.ParseFloat(inputType, 64)
if err != nil {
return nil, fmt.Errorf("Unable to convert field '%s' to type float: %v", name, err)
return nil, fmt.Errorf("unable to convert field '%s' to type float: %w", name, err)
}
return r, nil
case "bool":
r, err := strconv.ParseBool(inputType)
if err != nil {
return nil, fmt.Errorf("Unable to convert field '%s' to type bool: %v", name, err)
return nil, fmt.Errorf("unable to convert field '%s' to type bool: %w", name, err)
}
return r, nil
}
@ -639,7 +639,7 @@ func (p *Parser) convertType(input gjson.Result, desiredType string, name string
} else if inputType == 1 {
return true, nil
} else {
return nil, fmt.Errorf("Unable to convert field '%s' to type bool", name)
return nil, fmt.Errorf("unable to convert field '%s' to type bool", name)
}
}
default:

2
plugins/parsers/json_v2/testdata/wrong_path/expected.err vendored
View File

@ -1,6 +1,6 @@
the path wrong doesn't exist
the path wrong doesn't exist
the path wrong doesn't exist
The timestamp path wrong returned NULL
the timestamp path wrong returned NULL
the path wrong doesn't exist
the path wrong doesn't exist

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

@ -27,8 +27,8 @@ func getExitCode(err error) (int, error) {
return 0, nil
}
ee, ok := err.(*exec.ExitError)
if !ok {
var ee *exec.ExitError
if !errors.As(err, &ee) {
return unknownExitCode, err
}

7
plugins/parsers/prometheus/parser.go
View File

@ -3,6 +3,7 @@ package prometheus
import (
"bufio"
"bytes"
"errors"
"fmt"
"io"
"math"
@ -50,17 +51,17 @@ func (p *Parser) Parse(buf []byte) ([]telegraf.Metric, error) {
for {
mf := &dto.MetricFamily{}
if _, ierr := pbutil.ReadDelimited(reader, mf); ierr != nil {
if ierr == io.EOF {
if errors.Is(ierr, io.EOF) {
break
}
return nil, fmt.Errorf("reading metric family protocol buffer failed: %s", ierr)
return nil, fmt.Errorf("reading metric family protocol buffer failed: %w", ierr)
}
metricFamilies[mf.GetName()] = mf
}
} else {
metricFamilies, err = parser.TextToMetricFamilies(reader)
if err != nil {
return nil, fmt.Errorf("reading text format failed: %s", err)
return nil, fmt.Errorf("reading text format failed: %w", err)
}
}

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

@ -23,7 +23,7 @@ func (p *Parser) Parse(buf []byte) ([]telegraf.Metric, error) {
var req prompb.WriteRequest
if err := req.Unmarshal(buf); err != nil {
return nil, fmt.Errorf("unable to unmarshal request body: %s", err)
return nil, fmt.Errorf("unable to unmarshal request body: %w", err)
}
now := time.Now()
@ -70,11 +70,11 @@ func (p *Parser) ParseLine(line string) (telegraf.Metric, error) {
}
if len(metrics) < 1 {
return nil, fmt.Errorf("No metrics in line")
return nil, fmt.Errorf("no metrics in line")
}
if len(metrics) > 1 {
return nil, fmt.Errorf("More than one metric in line")
return nil, fmt.Errorf("more than one metric in line")
}
return metrics[0], nil

6
plugins/parsers/wavefront/element.go
View File

@ -92,7 +92,7 @@ func (ep *TimestampParser) parse(p *PointParser, pt *Point) error {
}
p.writeBuf.Reset()
for tok != EOF && tok == Number {
for tok == Number {
if _, err := p.writeBuf.WriteString(lit); err != nil {
return fmt.Errorf("unable to write: %w", err)
}
@ -136,7 +136,7 @@ func (ep *LoopedParser) parse(p *PointParser, pt *Point) error {
return err
}
err = ep.wsParser.parse(p, pt)
if err == ErrEOF {
if errors.Is(err, ErrEOF) {
break
}
}
@ -170,7 +170,7 @@ func (ep *TagParser) parse(p *PointParser, pt *Point) error {
func (ep *WhiteSpaceParser) parse(p *PointParser, _ *Point) error {
tok := Ws
for tok != EOF && tok == Ws {
for tok == Ws {
tok, _ = p.scan()
}

5
plugins/parsers/xpath/msgpack_document.go
View File

@ -4,10 +4,9 @@ import (
"bytes"
"fmt"
"github.com/tinylib/msgp/msgp"
"github.com/antchfx/jsonquery"
path "github.com/antchfx/xpath"
"github.com/tinylib/msgp/msgp"
)
type msgpackDocument jsonDocument
@ -17,7 +16,7 @@ func (d *msgpackDocument) Parse(buf []byte) (dataNode, error) {
// Unmarshal the message-pack binary message to JSON and proceed with the jsonquery class
if _, err := msgp.UnmarshalAsJSON(&json, buf); err != nil {
return nil, fmt.Errorf("unmarshalling to json failed: %v", err)
return nil, fmt.Errorf("unmarshalling to json failed: %w", err)
}
return jsonquery.Parse(&json)
}

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

@ -212,7 +212,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
if len(config.MetricQuery) > 0 {
v, err := p.executeQuery(doc, selected, config.MetricQuery)
if err != nil {
return nil, fmt.Errorf("failed to query metric name: %v", err)
return nil, fmt.Errorf("failed to query metric name: %w", err)
}
var ok bool
if metricname, ok = v.(string); !ok {
@ -229,7 +229,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
if len(config.Timestamp) > 0 {
v, err := p.executeQuery(doc, selected, config.Timestamp)
if err != nil {
return nil, fmt.Errorf("failed to query timestamp: %v", err)
return nil, fmt.Errorf("failed to query timestamp: %w", err)
}
if v != nil {
timestamp, err = internal.ParseTimestamp(config.TimestampFmt, v, "")
@ -245,7 +245,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
// Execute the query and cast the returned values into strings
v, err := p.executeQuery(doc, selected, query)
if err != nil {
return nil, fmt.Errorf("failed to query tag '%s': %v", name, err)
return nil, fmt.Errorf("failed to query tag '%s': %w", name, err)
}
switch v := v.(type) {
case string:
@ -282,7 +282,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
for _, selectedtag := range selectedTagNodes {
n, err := p.executeQuery(doc, selectedtag, tagnamequery)
if err != nil {
return nil, fmt.Errorf("failed to query tag name with query '%s': %v", tagnamequery, err)
return nil, fmt.Errorf("failed to query tag name with query '%s': %w", tagnamequery, err)
}
name, ok := n.(string)
if !ok {
@ -290,7 +290,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
}
v, err := p.executeQuery(doc, selectedtag, tagvaluequery)
if err != nil {
return nil, fmt.Errorf("failed to query tag value for '%s': %v", name, err)
return nil, fmt.Errorf("failed to query tag value for '%s': %w", name, err)
}
if config.TagNameExpand {
@ -333,13 +333,13 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
// Execute the query and cast the returned values into integers
v, err := p.executeQuery(doc, selected, query)
if err != nil {
return nil, fmt.Errorf("failed to query field (int) '%s': %v", name, err)
return nil, fmt.Errorf("failed to query field (int) '%s': %w", name, err)
}
switch v := v.(type) {
case string:
fields[name], err = strconv.ParseInt(v, 10, 54)
if err != nil {
return nil, fmt.Errorf("failed to parse field (int) '%s': %v", name, err)
return nil, fmt.Errorf("failed to parse field (int) '%s': %w", name, err)
}
case bool:
fields[name] = int64(0)
@ -359,7 +359,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
// Execute the query and store the result in fields
v, err := p.executeQuery(doc, selected, query)
if err != nil {
return nil, fmt.Errorf("failed to query field '%s': %v", name, err)
return nil, fmt.Errorf("failed to query field '%s': %w", name, err)
}
fields[name] = v
}
@ -385,7 +385,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
for _, selectedfield := range selectedFieldNodes {
n, err := p.executeQuery(doc, selectedfield, fieldnamequery)
if err != nil {
return nil, fmt.Errorf("failed to query field name with query '%s': %v", fieldnamequery, err)
return nil, fmt.Errorf("failed to query field name with query '%s': %w", fieldnamequery, err)
}
name, ok := n.(string)
if !ok {
@ -393,7 +393,7 @@ func (p *Parser) parseQuery(starttime time.Time, doc, selected dataNode, config
}
v, err := p.executeQuery(doc, selectedfield, fieldvaluequery)
if err != nil {
return nil, fmt.Errorf("failed to query field value for '%s': %v", name, err)
return nil, fmt.Errorf("failed to query field value for '%s': %w", name, err)
}
if config.FieldNameExpand {
@ -439,7 +439,7 @@ func (p *Parser) executeQuery(doc, selected dataNode, query string) (r interface
// Compile the query
expr, err := path.Compile(query)
if err != nil {
return nil, fmt.Errorf("failed to compile query '%s': %v", query, err)
return nil, fmt.Errorf("failed to compile query '%s': %w", query, err)
}
// Evaluate the compiled expression and handle returned node-iterators

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

@ -43,7 +43,7 @@ func (d *protobufDocument) Init() error {
}
fds, err := parser.ParseFiles(d.MessageDefinition)
if err != nil {
return fmt.Errorf("parsing protocol-buffer definition in %q failed: %v", d.MessageDefinition, err)
return fmt.Errorf("parsing protocol-buffer definition in %q failed: %w", d.MessageDefinition, err)
}
if len(fds) < 1 {
return fmt.Errorf("file %q does not contain file descriptors", d.MessageDefinition)
@ -52,7 +52,7 @@ func (d *protobufDocument) Init() error {
// Register all definitions in the file in the global registry
registry, err := protodesc.NewFiles(desc.ToFileDescriptorSet(fds...))
if err != nil {
return fmt.Errorf("constructing registry failed: %v", err)
return fmt.Errorf("constructing registry failed: %w", err)
}
// Lookup given type in the loaded file descriptors

2
plugins/processors/enum/enum.go
View File

@ -47,7 +47,7 @@ func (mapper *EnumMapper) Init() error {
if mapping.Tag != "" {
tagFilter, err := filter.NewIncludeExcludeFilter([]string{mapping.Tag}, nil)
if err != nil {
return fmt.Errorf("failed to create new tag filter: %s", err)
return fmt.Errorf("failed to create new tag filter: %w", err)
}
mapper.TagFilters[mapping.Tag] = tagFilter
}

5
plugins/processors/execd/execd.go
View File

@ -139,11 +139,12 @@ func (e *Execd) cmdReadOutStream(out io.Reader) {
if err != nil {
// Stop parsing when we've reached the end.
if err == influx.EOF {
if errors.Is(err, influx.EOF) {
break
}
if parseErr, isParseError := err.(*influx.ParseError); isParseError {
var parseErr *influx.ParseError
if errors.As(err, &parseErr) {
// Continue past parse errors.
e.acc.AddError(parseErr)
continue

6
plugins/processors/execd/execd_test.go
View File

@ -1,6 +1,7 @@
package execd
import (
"errors"
"flag"
"fmt"
"os"
@ -156,10 +157,11 @@ func runCountMultiplierProgram() {
for {
m, err := parser.Next()
if err != nil {
if err == influx.EOF {
if errors.Is(err, influx.EOF) {
return // stream ended
}
if parseErr, isParseError := err.(*influx.ParseError); isParseError {
var parseErr *influx.ParseError
if errors.As(err, &parseErr) {
fmt.Fprintf(os.Stderr, "parse ERR %v\n", parseErr)
//nolint:revive // os.Exit called intentionally
os.Exit(1)

4
plugins/processors/ifname/ifname.go
View File

@ -144,11 +144,11 @@ func (d *IfName) Start(acc telegraf.Accumulator) error {
d.ifTable, err = d.makeTable("1.3.6.1.2.1.2.2.1.2")
if err != nil {
return fmt.Errorf("preparing ifTable: %v", err)
return fmt.Errorf("preparing ifTable: %w", err)
}
d.ifXTable, err = d.makeTable("1.3.6.1.2.1.31.1.1.1.1")
if err != nil {
return fmt.Errorf("preparing ifXTable: %v", err)
return fmt.Errorf("preparing ifXTable: %w", err)
}
fn := func(m telegraf.Metric) []telegraf.Metric {

2
plugins/processors/noise/noise.go
View File

@ -94,7 +94,7 @@ func (*Noise) SampleConfig() string {
func (p *Noise) Init() error {
fieldFilter, err := filter.NewIncludeExcludeFilter(p.IncludeFields, p.ExcludeFields)
if err != nil {
return fmt.Errorf("creating fieldFilter failed: %v", err)
return fmt.Errorf("creating fieldFilter failed: %w", err)
}
p.fieldFilter = fieldFilter

4
plugins/processors/regex/regex.go
View File

@ -61,7 +61,7 @@ func (r *Regex) Init() error {
c.ResultKey = "keep"
}
if err := choice.Check(c.ResultKey, resultOptions); err != nil {
return fmt.Errorf("invalid metrics result_key: %v", err)
return fmt.Errorf("invalid metrics result_key: %w", err)
}
if _, compiled := r.regexCache[c.Pattern]; !compiled {
@ -78,7 +78,7 @@ func (r *Regex) Init() error {
c.ResultKey = "keep"
}
if err := choice.Check(c.ResultKey, resultOptions); err != nil {
return fmt.Errorf("invalid metrics result_key: %v", err)
return fmt.Errorf("invalid metrics result_key: %w", err)
}
if _, compiled := r.regexCache[c.Pattern]; !compiled {

2
plugins/processors/topk/topk.go
View File

@ -91,7 +91,7 @@ func (t *TopK) generateGroupByKey(m telegraf.Metric) (string, error) {
var err error
t.tagsGlobs, err = filter.Compile(t.GroupBy)
if err != nil {
return "", fmt.Errorf("could not compile pattern: %v %v", t.GroupBy, err)
return "", fmt.Errorf("could not compile pattern: %v %w", t.GroupBy, err)
}
}

5
plugins/secretstores/jose/jose.go
View File

@ -7,6 +7,7 @@ import (
"fmt"
"github.com/99designs/keyring"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/config"
"github.com/influxdata/telegraf/plugins/secretstores"
@ -41,7 +42,7 @@ func (j *Jose) Init() error {
passwd, err := j.Password.Get()
if err != nil {
return fmt.Errorf("getting password failed: %v", err)
return fmt.Errorf("getting password failed: %w", err)
}
defer config.ReleaseSecret(passwd)
@ -59,7 +60,7 @@ func (j *Jose) Init() error {
}
kr, err := keyring.Open(cfg)
if err != nil {
return fmt.Errorf("opening keyring failed: %v", err)
return fmt.Errorf("opening keyring failed: %w", err)
}
j.ring = kr

5
plugins/secretstores/os/os.go
View File

@ -8,6 +8,7 @@ import (
"fmt"
"github.com/99designs/keyring"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/config"
"github.com/influxdata/telegraf/plugins/secretstores"
@ -43,11 +44,11 @@ func (o *OS) Init() error {
// Setup the actual keyring
cfg, err := o.createKeyringConfig()
if err != nil {
return fmt.Errorf("getting keyring config failed: %v", err)
return fmt.Errorf("getting keyring config failed: %w", err)
}
kr, err := keyring.Open(cfg)
if err != nil {
return fmt.Errorf("opening keyring failed: %v", err)
return fmt.Errorf("opening keyring failed: %w", err)
}
o.ring = kr

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

@ -2,6 +2,7 @@ package influx
import (
"bytes"
"errors"
"fmt"
"io"
"log"
@ -113,7 +114,8 @@ func (s *Serializer) SerializeBatch(metrics []telegraf.Metric) ([]byte, error) {
for _, m := range metrics {
err := s.Write(&s.buf, m)
if err != nil {
if _, ok := err.(*MetricError); ok {
var mErr *MetricError
if errors.As(err, &mErr) {
continue
}
return nil, err

4
plugins/serializers/influx/reader.go
View File

@ -2,6 +2,7 @@ package influx
import (
"bytes"
"errors"
"io"
"log"
@ -53,7 +54,8 @@ func (r *reader) Read(p []byte) (int, error) {
r.offset++
if err != nil {
r.buf.Reset()
if _, ok := err.(*MetricError); ok {
var mErr *MetricError
if errors.As(err, &mErr) {
continue
}
// Since we are serializing multiple metrics, don't fail the

6
plugins/serializers/json/json.go
View File

@ -7,7 +7,7 @@ import (
"math"
"time"
jsonata "github.com/blues/jsonata-go"
"github.com/blues/jsonata-go"
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/filter"
@ -62,7 +62,7 @@ func (s *Serializer) Serialize(metric telegraf.Metric) ([]byte, error) {
var err error
if obj, err = s.transform(obj); err != nil {
if errors.Is(err, jsonata.ErrUndefined) {
return nil, fmt.Errorf("%v (maybe configured for batch mode?)", err)
return nil, fmt.Errorf("%w (maybe configured for batch mode?)", err)
}
return nil, err
}
@ -93,7 +93,7 @@ func (s *Serializer) SerializeBatch(metrics []telegraf.Metric) ([]byte, error) {
var err error
if obj, err = s.transform(obj); err != nil {
if errors.Is(err, jsonata.ErrUndefined) {
return nil, fmt.Errorf("%v (maybe configured for non-batch mode?)", err)
return nil, fmt.Errorf("%w (maybe configured for non-batch mode?)", err)
}
return nil, err
}

2
plugins/serializers/prometheusremotewrite/prometheusremotewrite.go
View File

@ -236,7 +236,7 @@ func (s *Serializer) SerializeBatch(metrics []telegraf.Metric) ([]byte, error) {
pb := &prompb.WriteRequest{Timeseries: promTS}
data, err := pb.Marshal()
if err != nil {
return nil, fmt.Errorf("unable to marshal protobuf: %v", err)
return nil, fmt.Errorf("unable to marshal protobuf: %w", err)
}
encoded := snappy.Encode(nil, data)
buf.Write(encoded) //nolint:revive // from buffer.go: "err is always nil"