fix: improve logging to fix lint

Author: genofire

cmd/config.go

@@ -1,10 +1,10 @@
 package cmd
 
 import (
-	"fmt"
 	"os"
 
 	"github.com/BurntSushi/toml"
+	"github.com/bdlm/log"
 
 	"github.com/FreifunkBremen/yanic/database"
 	"github.com/FreifunkBremen/yanic/respond"
@@ -29,7 +29,7 @@ var (
 func loadConfig() *Config {
 	config, err := ReadConfigFile(configPath)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "unable to load config file:", err)
+		log.WithError(err).Error("unable to load config file")
 		os.Exit(2)
 	}
 	return config
@@ -43,7 +43,11 @@ func ReadConfigFile(path string) (config *Config, err error) {
 	if err != nil {
 		return nil, err
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			log.WithError(err).Error("failed to close after read config")
+		}
+	}()
 
 	_, err = toml.NewDecoder(file).Decode(config)
 	if err != nil {

cmd/serve.go

@@ -26,7 +26,7 @@ var serveCmd = &cobra.Command{
 
 		err := allDatabase.Start(config.Database)
 		if err != nil {
-			log.Panicf("could not connect to database: %s", err)
+			log.WithError(err).Panic("could not connect to database")
 		}
 		defer allDatabase.Close()
 
@@ -35,15 +35,19 @@ var serveCmd = &cobra.Command{
 
 		err = allOutput.Start(nodes, config.Nodes)
 		if err != nil {
-			log.Panicf("error on init outputs: %s", err)
+			log.WithError(err).Panicf("error on init outputs")
 		}
 		defer allOutput.Close()
 
 		if config.Webserver.Enable {
-			log.Infof("starting webserver on %s", config.Webserver.Bind)
+			log.WithField("address", config.Webserver.Bind).Info("starting webserver")
 			srv := webserver.New(config.Webserver.Bind, config.Webserver.Webroot)
 			go webserver.Start(srv)
-			defer srv.Close()
+			defer func() {
+				if err := srv.Close(); err != nil {
+					log.WithError(err).Panic("could not stop webserver")
+				}
+			}()
 		}
 
 		if config.Respondd.Enable {

data/statistics.go

@@ -5,7 +5,7 @@ package data
 	They always return float.
 */
 
-//Statistics struct
+// Statistics struct
 type Statistics struct {
 	NodeID         string  `json:"node_id"`
 	Clients        Clients `json:"clients"`

database/graphite/database.go

@@ -58,17 +58,18 @@ func Connect(configuration map[string]interface{}) (database.Connection, error)
 func (c *Connection) Close() {
 	close(c.points)
 	if c.client.Connection != nil {
-		c.client.Close()
+		if err := c.client.Close(); err != nil {
+			log.WithError(err).Error("unable close connection")
+		}
 	}
 }
 
 func (c *Connection) addWorker() {
 	defer c.wg.Done()
 	defer c.Close()
 	for point := range c.points {
-		err := c.client.SendAll(point)
-		if err != nil {
-			log.WithField("database", "graphite").Fatal(err)
+		if err := c.client.SendAll(point); err != nil {
+			log.WithError(err).WithField("database", "graphite").Fatal("unable to store data")
 			return
 		}
 	}

database/influxdb/database.go

@@ -142,7 +142,9 @@ func (conn *Connection) addPoint(name string, tags models.Tags, fields models.Fi
 func (conn *Connection) Close() {
 	close(conn.points)
 	conn.wg.Wait()
-	conn.client.Close()
+	if err := conn.client.Close(); err != nil {
+		log.WithError(err).Error("during close connection")
+	}
 }
 
 // stores data points in batches into the influxdb
@@ -166,7 +168,7 @@ func (conn *Connection) addWorker() {
 					// create new batch
 					timer.Reset(batchTimeout)
 					if bp, err = client.NewBatchPoints(bpConfig); err != nil {
-						log.Fatal(err)
+						log.WithError(err).Fatal("not able to create new batch for points")
 					}
 				}
 				bp.AddPoint(point)
@@ -186,7 +188,7 @@ func (conn *Connection) addWorker() {
 			log.WithField("count", len(bp.Points())).Info("saving points")
 
 			if err = conn.client.Write(bp); err != nil {
-				log.Error(err)
+				log.WithError(err).Error("not able to write batch of points")
 			}
 			writeNow = false
 			bp = nil

database/influxdb/node_test.go

@@ -126,8 +126,8 @@ func TestToInflux(t *testing.T) {
 					Subtarget string `json:"subtarget,omitempty"`
 					ImageName string `json:"image_name,omitempty"`
 				}{
-					Base: "gluon",
-					Target: "x86",
+					Base:      "gluon",
+					Target:    "x86",
 					Subtarget: "64",
 					ImageName: "x86-64",
 				},

database/logging/file.go

@@ -11,6 +11,8 @@ import (
 	"os"
 	"time"
 
+	logger "github.com/bdlm/log"
+
 	"github.com/FreifunkBremen/yanic/database"
 	"github.com/FreifunkBremen/yanic/runtime"
 )
@@ -59,7 +61,9 @@ func (conn *Connection) PruneNodes(deleteAfter time.Duration) {
 
 func (conn *Connection) Close() {
 	conn.log("Close")
-	conn.file.Close()
+	if err := conn.file.Close(); err != nil {
+		logger.WithError(err).Error("unable to close connection")
+	}
 }
 
 func (conn *Connection) log(v ...interface{}) {

database/logging/file_test.go

@@ -1,6 +1,7 @@
 package logging
 
 import (
+	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -56,5 +57,7 @@ func TestStart(t *testing.T) {
 	dat, _ = os.ReadFile(path)
 	assert.Contains(string(dat), "Close")
 
-	os.Remove(path)
+	if err := os.Remove(path); err != nil {
+		fmt.Printf("during cleanup: %s\n", err)
+	}
 }

database/respondd/main.go

@@ -33,8 +33,11 @@ func (c Config) Address() string {
 	return c["address"].(string)
 }
 
+var logger *log.Entry
+
 func init() {
 	database.RegisterAdapter("respondd", Connect)
+	logger = log.WithField("type", "database-yanic")
 }
 
 func Connect(configuration map[string]interface{}) (database.Connection, error) {
@@ -59,26 +62,30 @@ func (conn *Connection) InsertNode(node *runtime.Node) {
 
 	flater, err := flate.NewWriter(writer, flate.BestCompression)
 	if err != nil {
-		log.Errorf("[database-yanic] could not create flater: %s", err)
+		logger.WithError(err).Error("could not create flater")
 		return
 	}
-	defer flater.Close()
+	defer func() {
+		if err := flater.Close(); err != nil {
+			logger.WithError(err).Error("could not close flater")
+		}
+	}()
 	err = json.NewEncoder(flater).Encode(res)
 	if err != nil {
 		nodeid := "unknown"
 		if node.Nodeinfo != nil && node.Nodeinfo.NodeID != "" {
 			nodeid = node.Nodeinfo.NodeID
 		}
-		log.WithField("node_id", nodeid).Errorf("[database-yanic] could not encode node: %s", err)
+		logger.WithError(err).WithField("node_id", nodeid).Error("could not encode node")
 		return
 	}
 	err = flater.Flush()
 	if err != nil {
-		log.Errorf("[database-yanic] could not compress: %s", err)
+		logger.WithError(err).Error("could not compress")
 	}
 	err = writer.Flush()
 	if err != nil {
-		log.Errorf("[database-yanic] could not send: %s", err)
+		logger.WithError(err).Error("could not send")
 	}
 }
 
@@ -92,5 +99,7 @@ func (conn *Connection) PruneNodes(deleteAfter time.Duration) {
 }
 
 func (conn *Connection) Close() {
-	conn.conn.Close()
+	if err := conn.conn.Close(); err != nil {
+		logger.WithError(err).Error("cound not close socket")
+	}
 }

lib/jsontime/jsontime.go

@@ -8,7 +8,7 @@ import (
 // TimeFormat of JSONTime
 const TimeFormat = "2006-01-02T15:04:05-0700"
 
-//Time struct of JSONTime
+// Time struct of JSONTime
 type Time struct {
 	time time.Time
 }
@@ -18,7 +18,7 @@ func Now() Time {
 	return Time{time.Now()}
 }
 
-//MarshalJSON to bytearray
+// MarshalJSON to bytearray
 func (t Time) MarshalJSON() ([]byte, error) {
 	stamp := `"` + t.time.Format(TimeFormat) + `"`
 	return []byte(stamp), nil