use zap for logging (#1112)

Use zap for logging

canaryconfigmgr/prometheusClient.go

@@ -20,26 +20,26 @@ import (
 	"fmt"
 	"time"
 
-	"golang.org/x/net/context"
-
+	"github.com/pkg/errors"
 	promClient "github.com/prometheus/client_golang/api/prometheus"
 	"github.com/prometheus/common/model"
-	log "github.com/sirupsen/logrus"
+	"go.uber.org/zap"
+	"golang.org/x/net/context"
 )
 
 type PrometheusApiClient struct {
+	logger *zap.Logger
 	client promClient.QueryAPI
 }
 
-func MakePrometheusClient(prometheusSvc string) (*PrometheusApiClient, error) {
+func MakePrometheusClient(logger *zap.Logger, prometheusSvc string) (*PrometheusApiClient, error) {
 	promApiConfig := promClient.Config{
 		Address: prometheusSvc,
 	}
 
 	promApiClient, err := promClient.New(promApiConfig)
 	if err != nil {
-		log.Errorf("Error creating prometheus api client for svc : %s, err : %v", prometheusSvc, err)
-		return nil, err
+		return nil, errors.Wrapf(err, "error creating prometheus api client for svc: %s", prometheusSvc)
 	}
 
 	apiQueryClient := promClient.NewQueryAPI(promApiClient)
@@ -56,12 +56,12 @@ func MakePrometheusClient(prometheusSvc string) (*PrometheusApiClient, error) {
 	}
 
 	if err != nil {
-		log.Printf("Error sending test query to prometheus server: %v", err)
-		return nil, err
+		return nil, errors.Wrap(err, "error sending test query to prometheus server")
 	}
 
-	log.Printf("Successfully made prometheus client with service : %s", prometheusSvc)
+	logger.Info("successfully made prometheus client with service", zap.String("service", prometheusSvc))
 	return &PrometheusApiClient{
+		logger: logger.Named("prometheus_api_client"),
 		client: apiQueryClient,
 	}, nil
 }
@@ -74,7 +74,7 @@ func (promApiClient *PrometheusApiClient) GetFunctionFailurePercentage(path, met
 	}
 
 	if reqs <= 0 {
-		return -1, fmt.Errorf("no requests to this url %v and method %v in the window : %v", path, method, window)
+		return -1, fmt.Errorf("no requests to this url %v and method %v in the window: %v", path, method, window)
 	}
 
 	// next, get a total count of errored out requests to this function in the same window
@@ -94,20 +94,22 @@ func (promApiClient *PrometheusApiClient) GetRequestsToFuncInWindow(path string,
 
 	reqs, err := promApiClient.executeQuery(queryString)
 	if err != nil {
-		log.Printf("Error executing query : %s, err : %v", queryString, err)
-		return 0, err
+		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
 	}
 
 	queryString = fmt.Sprintf("fission_function_calls_total{path=\"%s\",method=\"%s\",name=\"%s\",namespace=\"%s\"} offset %v", path, method, funcName, funcNs, window)
 
 	reqsInPrevWindow, err := promApiClient.executeQuery(queryString)
 	if err != nil {
-		log.Printf("Error executing query : %s, err : %v", queryString, err)
-		return 0, err
+		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
 	}
 
 	reqsInCurrentWindow := reqs - reqsInPrevWindow
-	log.Printf("reqs : %v, reqsInPrevWindow : %v, reqsInCurrentWindow : %v to function %v", reqs, reqsInPrevWindow, reqsInCurrentWindow, funcName)
+	promApiClient.logger.Info("function requests",
+		zap.Float64("requests", reqs),
+		zap.Float64("requests_in_previous_window", reqsInPrevWindow),
+		zap.Float64("requests_in_current_window", reqsInCurrentWindow),
+		zap.String("function", funcName))
 
 	return reqsInCurrentWindow, nil
 }
@@ -117,20 +119,22 @@ func (promApiClient *PrometheusApiClient) GetTotalFailedRequestsToFuncInWindow(f
 
 	failedRequests, err := promApiClient.executeQuery(queryString)
 	if err != nil {
-		log.Printf("Error executing query : %s, err : %v", queryString, err)
-		return 0, err
+		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
 	}
 
 	queryString = fmt.Sprintf("fission_function_errors_total{name=\"%s\",namespace=\"%s\",path=\"%s\", method=\"%s\"} offset %v", funcName, funcNs, path, method, window)
 
 	failedReqsInPrevWindow, err := promApiClient.executeQuery(queryString)
 	if err != nil {
-		log.Printf("Error executing query : %s, err : %v", queryString, err)
-		return 0, err
+		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
 	}
 
 	failedReqsInCurrentWindow := failedRequests - failedReqsInPrevWindow
-	log.Printf("failedReqs : %v, failedReqsInPrevWindow : %v, failedReqsInCurrentWindow : %v to function : %v", failedRequests, failedReqsInPrevWindow, failedReqsInCurrentWindow, funcName)
+	promApiClient.logger.Info("function requests",
+		zap.Float64("failed_requests", failedRequests),
+		zap.Float64("failed_requests_in_previous_window", failedReqsInPrevWindow),
+		zap.Float64("failed_requests_in_current_window", failedReqsInCurrentWindow),
+		zap.String("function", funcName))
 
 	return failedReqsInCurrentWindow, nil
 }
@@ -138,8 +142,7 @@ func (promApiClient *PrometheusApiClient) GetTotalFailedRequestsToFuncInWindow(f
 func (promApiClient *PrometheusApiClient) executeQuery(queryString string) (float64, error) {
 	val, err := promApiClient.client.Query(context.Background(), queryString, time.Now())
 	if err != nil {
-		log.Errorf("Error querying prometheus qs : %v, err : %v", queryString, err)
-		return 0, err
+		return 0, errors.Wrapf(err, "error querying prometheus")
 	}
 
 	switch {
@@ -159,23 +162,13 @@ func (promApiClient *PrometheusApiClient) executeQuery(queryString string) (floa
 		matrixVal := val.(model.Matrix)
 		total := float64(0)
 		for _, elem := range matrixVal {
-			//log.Printf("Only one value, so taking the 0th elem")
 			total += float64(elem.Values[len(elem.Values)-1].Value)
 		}
 		return total, nil
 
 	default:
-		log.Printf("type unrecognized")
+		promApiClient.logger.Info("return value type of prometheus query was unrecognized",
+			zap.Any("type", val.Type()))
 		return 0, nil
 	}
 }
-
-func addInterval(window string) string {
-	timeDuration, _ := time.ParseDuration(window)
-	log.Println("window in seconds", int64(timeDuration/time.Second))
-
-	timeInStr := fmt.Sprintf("%ds", int64((timeDuration+timeDuration)/time.Second))
-	fmt.Println(timeInStr)
-
-	return timeInStr
-}