chore(linters): Remove blank identifiers and errors which are not needed to be handled

cmd/telegraf/cmd_secretstore.go

@@ -109,15 +109,15 @@ To also reveal the actual secret, i.e. the value, you can pass the
 							}
 							sort.Strings(keys)
 
-							_, _ = fmt.Printf("Known secrets for store %q:\n", storeID)
+							fmt.Printf("Known secrets for store %q:\n", storeID)
 							for _, k := range keys {
 								var v []byte
 								if reveal {
 									if v, err = store.Get(k); err != nil {
 										return fmt.Errorf("unable to get value of secret %q from store %q: %w", k, storeID, err)
 									}
 								}
-								_, _ = fmt.Printf("    %-30s  %s\n", k, string(v))
+								fmt.Printf("    %-30s  %s\n", k, string(v))
 								memguard.WipeBytes(v)
 							}
 						}
@@ -178,7 +178,7 @@ with the ID 'mystore'.
 						if err != nil {
 							return fmt.Errorf("unable to get secret: %w", err)
 						}
-						_, _ = fmt.Printf("%s:%s = %s\n", storeID, key, value)
+						fmt.Printf("%s:%s = %s\n", storeID, key, value)
 
 						return nil
 					},

config/envvar.go

@@ -58,9 +58,7 @@ func (t *trimmer) process() error {
 		case '#':
 			err = t.comment()
 		default:
-			if err := t.output.WriteByte(c); err != nil {
-				return err
-			}
+			t.output.WriteByte(c)
 			continue
 		}
 		if err != nil {
@@ -165,9 +163,7 @@ func (t *trimmer) doubleQuote() error {
 			// Found terminator
 			return t.output.WriteByte(c)
 		}
-		if err := t.output.WriteByte(c); err != nil {
-			return err
-		}
+		t.output.WriteByte(c)
 	}
 }
 
@@ -192,7 +188,7 @@ func (t *trimmer) tripleDoubleQuote() error {
 			}
 			continue
 		case '"':
-			_ = t.output.WriteByte(c)
+			t.output.WriteByte(c)
 			if t.hasNQuotes('"', 2) {
 				// Consumer the two additional ending quotes
 				_, _ = t.readWriteByte()
@@ -201,9 +197,7 @@ func (t *trimmer) tripleDoubleQuote() error {
 			}
 			continue
 		}
-		if err := t.output.WriteByte(c); err != nil {
-			return err
-		}
+		t.output.WriteByte(c)
 	}
 }
 

config/migration.go

@@ -92,8 +92,8 @@ func assignTextToSections(data []byte, sections []section) ([]section, error) {
 
 			line := strings.TrimSpace(scanner.Text())
 			if strings.HasPrefix(line, "#") {
-				_, _ = buf.Write(scanner.Bytes())
-				_, _ = buf.WriteString("\n")
+				buf.Write(scanner.Bytes())
+				buf.WriteString("\n")
 				continue
 			} else if buf.Len() > 0 {
 				if _, err := io.Copy(sections[idx].raw, &buf); err != nil {
@@ -102,8 +102,8 @@ func assignTextToSections(data []byte, sections []section) ([]section, error) {
 				buf.Reset()
 			}
 
-			_, _ = sections[idx].raw.Write(scanner.Bytes())
-			_, _ = sections[idx].raw.WriteString("\n")
+			sections[idx].raw.Write(scanner.Bytes())
+			sections[idx].raw.WriteString("\n")
 		}
 		if err := scanner.Err(); err != nil {
 			return nil, fmt.Errorf("splitting by line failed: %w", err)
@@ -120,8 +120,8 @@ func assignTextToSections(data []byte, sections []section) ([]section, error) {
 	}
 	// Write the remaining to the last section
 	for scanner.Scan() {
-		_, _ = sections[len(sections)-1].raw.Write(scanner.Bytes())
-		_, _ = sections[len(sections)-1].raw.WriteString("\n")
+		sections[len(sections)-1].raw.Write(scanner.Bytes())
+		sections[len(sections)-1].raw.WriteString("\n")
 	}
 	if err := scanner.Err(); err != nil {
 		return nil, fmt.Errorf("splitting by line failed: %w", err)

config/plugin_id.go

@@ -69,16 +69,10 @@ func generatePluginID(prefix string, table *ast.Table) (string, error) {
 	// Hash the config options to get the ID. We also prefix the ID with
 	// the plugin name to prevent overlap with other plugin types.
 	hash := sha256.New()
-	if _, err := hash.Write(append([]byte(prefix), 0)); err != nil {
-		return "", fmt.Errorf("hashing name failed: %w", err)
-	}
+	hash.Write(append([]byte(prefix), 0))
 	for _, kv := range cfg {
-		if _, err := hash.Write([]byte(kv.Key + ":" + kv.Value)); err != nil {
-			return "", fmt.Errorf("hashing entry %q failed: %w", kv.Key, err)
-		}
-		if _, err := hash.Write([]byte{0}); err != nil {
-			return "", fmt.Errorf("adding option end marker failed: %w", err)
-		}
+		hash.Write([]byte(kv.Key + ":" + kv.Value))
+		hash.Write([]byte{0})
 	}
 
 	return hex.EncodeToString(hash.Sum(nil)), nil

internal/internal.go

@@ -225,7 +225,7 @@ func CompressWithGzip(data io.Reader) io.ReadCloser {
 		// instance reading from the reader returned by the CompressWithGzip
 		// function. If "err" is nil, the below function will correctly report
 		// io.EOF.
-		_ = pipeWriter.CloseWithError(err)
+		pipeWriter.CloseWithError(err)
 	}()
 
 	// Return a reader which then can be read by the caller to collect the

plugins/inputs/ceph/ceph_test.go

@@ -173,8 +173,7 @@ func assertFoundSocket(t *testing.T, dir, sockType string, i int, sockets []*soc
 	expected := filepath.Join(dir, sockFile(prefix, i))
 	found := false
 	for _, s := range sockets {
-		_, err := fmt.Printf("Checking %s\n", s.socket)
-		require.NoError(t, err)
+		fmt.Printf("Checking %s\n", s.socket)
 		if s.socket == expected {
 			found = true
 			require.Equal(t, s.sockType, sockType, "Unexpected socket type for %q", s)

plugins/inputs/cisco_telemetry_mdt/cisco_telemetry_mdt.go

@@ -337,9 +337,7 @@ func (c *CiscoTelemetryMDT) MdtDialout(stream dialout.GRPCMdtDialout_MdtDialoutS
 		if packet.TotalSize == 0 {
 			c.handleTelemetry(packet.Data)
 		} else if int(packet.TotalSize) <= c.MaxMsgSize {
-			if _, err := chunkBuffer.Write(packet.Data); err != nil {
-				c.acc.AddError(fmt.Errorf("writing packet %q failed: %w", packet.Data, err))
-			}
+			chunkBuffer.Write(packet.Data)
 			if chunkBuffer.Len() >= int(packet.TotalSize) {
 				c.handleTelemetry(chunkBuffer.Bytes())
 				chunkBuffer.Reset()

plugins/inputs/exec/exec.go

@@ -85,7 +85,7 @@ func removeWindowsCarriageReturns(b bytes.Buffer) bytes.Buffer {
 			byt, err := b.ReadBytes(0x0D)
 			byt = bytes.TrimRight(byt, "\x0d")
 			if len(byt) > 0 {
-				_, _ = buf.Write(byt)
+				buf.Write(byt)
 			}
 			if errors.Is(err, io.EOF) {
 				return buf

plugins/inputs/exec/exec_test.go

@@ -232,29 +232,25 @@ func TestTruncate(t *testing.T) {
 			name: "should not truncate",
 			bufF: func() *bytes.Buffer {
 				var b bytes.Buffer
-				_, err := b.WriteString("hello world")
-				require.NoError(t, err)
+				b.WriteString("hello world")
 				return &b
 			},
 			expF: func() *bytes.Buffer {
 				var b bytes.Buffer
-				_, err := b.WriteString("hello world")
-				require.NoError(t, err)
+				b.WriteString("hello world")
 				return &b
 			},
 		},
 		{
 			name: "should truncate up to the new line",
 			bufF: func() *bytes.Buffer {
 				var b bytes.Buffer
-				_, err := b.WriteString("hello world\nand all the people")
-				require.NoError(t, err)
+				b.WriteString("hello world\nand all the people")
 				return &b
 			},
 			expF: func() *bytes.Buffer {
 				var b bytes.Buffer
-				_, err := b.WriteString("hello world...")
-				require.NoError(t, err)
+				b.WriteString("hello world...")
 				return &b
 			},
 		},
@@ -263,17 +259,16 @@ func TestTruncate(t *testing.T) {
 			bufF: func() *bytes.Buffer {
 				var b bytes.Buffer
 				for i := 0; i < 2*MaxStderrBytes; i++ {
-					require.NoError(t, b.WriteByte('b'))
+					b.WriteByte('b')
 				}
 				return &b
 			},
 			expF: func() *bytes.Buffer {
 				var b bytes.Buffer
 				for i := 0; i < MaxStderrBytes; i++ {
-					require.NoError(t, b.WriteByte('b'))
+					b.WriteByte('b')
 				}
-				_, err := b.WriteString("...")
-				require.NoError(t, err)
+				b.WriteString("...")
 				return &b
 			},
 		},

plugins/inputs/minecraft/internal/rcon/rcon.go

@@ -74,12 +74,8 @@ func (p Packet) Compile() (payload []byte, err error) {
 		return nil, err
 	}
 
-	if _, err = buffer.WriteString(p.Body); err != nil {
-		return nil, err
-	}
-	if _, err = buffer.Write(padding[:]); err != nil {
-		return nil, err
-	}
+	buffer.WriteString(p.Body)
+	buffer.Write(padding[:])
 
 	return buffer.Bytes(), nil
 }

plugins/inputs/modbus/configuration_metric.go

@@ -142,10 +142,7 @@ func (c *ConfigurationPerMetric) Check() error {
 			def.Fields[fidx] = f
 
 			// Check for duplicate field definitions
-			id, err := c.fieldID(seed, def, f)
-			if err != nil {
-				return fmt.Errorf("cannot determine field id for %q: %w", f.Name, err)
-			}
+			id := c.fieldID(seed, def, f)
 			if seenFields[id] {
 				return fmt.Errorf("field %q duplicated in measurement %q (slave %d)", f.Name, def.Measurement, def.SlaveID)
 			}
@@ -313,55 +310,29 @@ func (c *ConfigurationPerMetric) newField(def metricFieldDefinition, mdef metric
 	return f, nil
 }
 
-func (c *ConfigurationPerMetric) fieldID(seed maphash.Seed, def metricDefinition, field metricFieldDefinition) (uint64, error) {
+func (c *ConfigurationPerMetric) fieldID(seed maphash.Seed, def metricDefinition, field metricFieldDefinition) uint64 {
 	var mh maphash.Hash
 	mh.SetSeed(seed)
 
-	if err := mh.WriteByte(def.SlaveID); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
-	if _, err := mh.WriteString(field.RegisterType); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
-	if _, err := mh.WriteString(def.Measurement); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
-	if _, err := mh.WriteString(field.Name); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
+	mh.WriteByte(def.SlaveID)
+	mh.WriteByte(0)
+	mh.WriteString(field.RegisterType)
+	mh.WriteByte(0)
+	mh.WriteString(def.Measurement)
+	mh.WriteByte(0)
+	mh.WriteString(field.Name)
+	mh.WriteByte(0)
 
 	// Tags
 	for k, v := range def.Tags {
-		if _, err := mh.WriteString(k); err != nil {
-			return 0, err
-		}
-		if err := mh.WriteByte('='); err != nil {
-			return 0, err
-		}
-		if _, err := mh.WriteString(v); err != nil {
-			return 0, err
-		}
-		if err := mh.WriteByte(':'); err != nil {
-			return 0, err
-		}
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
+		mh.WriteString(k)
+		mh.WriteByte('=')
+		mh.WriteString(v)
+		mh.WriteByte(':')
 	}
+	mh.WriteByte(0)
 
-	return mh.Sum64(), nil
+	return mh.Sum64()
 }
 
 func (c *ConfigurationPerMetric) determineOutputDatatype(input string) (string, error) {

plugins/inputs/modbus/configuration_request.go

@@ -179,10 +179,7 @@ func (c *ConfigurationPerRequest) Check() error {
 			def.Fields[fidx] = f
 
 			// Check for duplicate field definitions
-			id, err := c.fieldID(seed, def, f)
-			if err != nil {
-				return fmt.Errorf("cannot determine field id for %q: %w", f.Name, err)
-			}
+			id := c.fieldID(seed, def, f)
 			if seenFields[id] {
 				return fmt.Errorf("field %q duplicated in measurement %q (slave %d/%q)", f.Name, f.Measurement, def.SlaveID, def.RegisterType)
 			}
@@ -360,55 +357,29 @@ func (c *ConfigurationPerRequest) newFieldFromDefinition(def requestFieldDefinit
 	return f, nil
 }
 
-func (c *ConfigurationPerRequest) fieldID(seed maphash.Seed, def requestDefinition, field requestFieldDefinition) (uint64, error) {
+func (c *ConfigurationPerRequest) fieldID(seed maphash.Seed, def requestDefinition, field requestFieldDefinition) uint64 {
 	var mh maphash.Hash
 	mh.SetSeed(seed)
 
-	if err := mh.WriteByte(def.SlaveID); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
-	if _, err := mh.WriteString(def.RegisterType); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
-	if _, err := mh.WriteString(field.Measurement); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
-	if _, err := mh.WriteString(field.Name); err != nil {
-		return 0, err
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
-	}
+	mh.WriteByte(def.SlaveID)
+	mh.WriteByte(0)
+	mh.WriteString(def.RegisterType)
+	mh.WriteByte(0)
+	mh.WriteString(field.Measurement)
+	mh.WriteByte(0)
+	mh.WriteString(field.Name)
+	mh.WriteByte(0)
 
 	// Tags
 	for k, v := range def.Tags {
-		if _, err := mh.WriteString(k); err != nil {
-			return 0, err
-		}
-		if err := mh.WriteByte('='); err != nil {
-			return 0, err
-		}
-		if _, err := mh.WriteString(v); err != nil {
-			return 0, err
-		}
-		if err := mh.WriteByte(':'); err != nil {
-			return 0, err
-		}
-	}
-	if err := mh.WriteByte(0); err != nil {
-		return 0, err
+		mh.WriteString(k)
+		mh.WriteByte('=')
+		mh.WriteString(v)
+		mh.WriteByte(':')
 	}
+	mh.WriteByte(0)
 
-	return mh.Sum64(), nil
+	return mh.Sum64()
 }
 
 func (c *ConfigurationPerRequest) determineOutputDatatype(input string) (string, error) {