use zap for logging (#1112)

Use zap for logging
2019-03-14 21:11:15 +05:30
parent c717f182b6
commit 0fc864f230
98 changed files with 2031 additions and 1223 deletions
@@ -42,7 +42,6 @@ package router
 import (
 	"context"
 	"fmt"
-	"log"
 	"net/http"
 	"os"
 	"strconv"
@@ -52,6 +51,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"go.opencensus.io/plugin/ochttp"
 	"go.opencensus.io/trace"
+	"go.uber.org/zap"

 	"github.com/fission/fission"
 	"github.com/fission/fission/crd"
@@ -63,16 +63,16 @@ import (

 // request url ---[trigger]---> Function(name, deployment) ----[deployment]----> Function(name, uid) ----[pool mgr]---> k8s service url

-func router(ctx context.Context, httpTriggerSet *HTTPTriggerSet, resolver *functionReferenceResolver) *mutableRouter {
+func router(ctx context.Context, logger *zap.Logger, httpTriggerSet *HTTPTriggerSet, resolver *functionReferenceResolver) *mutableRouter {
 	muxRouter := mux.NewRouter()
-	mr := NewMutableRouter(muxRouter)
-	muxRouter.Use(fission.LoggingMiddleware)
+	mr := NewMutableRouter(logger, muxRouter)
+	muxRouter.Use(fission.LoggingMiddleware(logger))
 	httpTriggerSet.subscribeRouter(ctx, mr, resolver)
 	return mr
 }

-func serve(ctx context.Context, port int, httpTriggerSet *HTTPTriggerSet, resolver *functionReferenceResolver) {
-	mr := router(ctx, httpTriggerSet, resolver)
+func serve(ctx context.Context, logger *zap.Logger, port int, httpTriggerSet *HTTPTriggerSet, resolver *functionReferenceResolver) {
+	mr := router(ctx, logger, httpTriggerSet, resolver)
 	url := fmt.Sprintf(":%v", port)
 	http.ListenAndServe(url, &ochttp.Handler{
 		Handler: mr,
@@ -82,77 +82,102 @@ func serve(ctx context.Context, port int, httpTriggerSet *HTTPTriggerSet, resolv
 	})
 }

-func serveMetric() {
+func serveMetric(logger *zap.Logger) {
 	// Expose the registered metrics via HTTP.
 	http.Handle("/metrics", promhttp.Handler())
-	log.Fatal(http.ListenAndServe(metricAddr, nil))
+	err := http.ListenAndServe(metricAddr, nil)
+
+	logger.Fatal("done listening on metrics endpoint", zap.Error(err))
 }

-func Start(port int, executorUrl string) {
+func Start(logger *zap.Logger, port int, executorUrl string) {
 	// setup a signal handler for SIGTERM
 	fission.SetupStackTraceHandler()

-	fmap := makeFunctionServiceMap(time.Minute)
+	fmap := makeFunctionServiceMap(logger, time.Minute)

-	frmap := makeFunctionRecorderMap(time.Minute)
+	frmap := makeFunctionRecorderMap(logger, time.Minute)

-	trmap := makeTriggerRecorderMap(time.Minute)
+	trmap := makeTriggerRecorderMap(logger, time.Minute)

 	fissionClient, kubeClient, _, err := crd.MakeFissionClient()
 	if err != nil {
-		log.Fatalf("Error connecting to kubernetes API: %v", err)
+		logger.Fatal("error connecting to kubernetes API", zap.Error(err))
 	}

 	err = fissionClient.WaitForCRDs()
 	if err != nil {
-		log.Fatalf("Error waiting for CRDs: %v", err)
+		logger.Fatal("error waiting for CRDs", zap.Error(err))
 	}

 	restClient := fissionClient.GetCrdClient()

-	executor := executorClient.MakeClient(executorUrl)
+	executor := executorClient.MakeClient(logger, executorUrl)

-	timeout, err := time.ParseDuration(os.Getenv("ROUTER_ROUND_TRIP_TIMEOUT"))
+	timeoutStr := os.Getenv("ROUTER_ROUND_TRIP_TIMEOUT")
+	timeout, err := time.ParseDuration(timeoutStr)
 	if err != nil {
-		log.Fatalf("Failed to parse timeout: %v", err)
+		logger.Fatal("failed to parse timeout duration from 'ROUTER_ROUND_TRIP_TIMEOUT'",
+			zap.Error(err),
+			zap.String("value", timeoutStr))
 	}

-	timeoutExponent, err := strconv.Atoi(os.Getenv("ROUTER_ROUNDTRIP_TIMEOUT_EXPONENT"))
+	timeoutExponentStr := os.Getenv("ROUTER_ROUNDTRIP_TIMEOUT_EXPONENT")
+	timeoutExponent, err := strconv.Atoi(timeoutExponentStr)
 	if err != nil {
-		log.Fatalf("Failed to parse timeout exponent: %v", err)
+		logger.Fatal("failed to parse timeout exponent from 'ROUTER_ROUNDTRIP_TIMEOUT_EXPONENT'",
+			zap.Error(err),
+			zap.String("value", timeoutExponentStr))
 	}

-	keepAlive, err := time.ParseDuration(os.Getenv("ROUTER_ROUND_TRIP_KEEP_ALIVE_TIME"))
+	keepAliveStr := os.Getenv("ROUTER_ROUND_TRIP_KEEP_ALIVE_TIME")
+	keepAlive, err := time.ParseDuration(keepAliveStr)
 	if err != nil {
-		log.Fatalf("Failed to parse keep alive time: %v", err)
+		logger.Fatal("failed to parse keep alive duration from 'ROUTER_ROUND_TRIP_KEEP_ALIVE_TIME'",
+			zap.Error(err),
+			zap.String("value", keepAliveStr))
 	}

-	maxRetries, err := strconv.Atoi(os.Getenv("ROUTER_ROUND_TRIP_MAX_RETRIES"))
+	maxRetriesStr := os.Getenv("ROUTER_ROUND_TRIP_MAX_RETRIES")
+	maxRetries, err := strconv.Atoi(maxRetriesStr)
 	if err != nil {
-		log.Fatalf("Failed to parse max retry times: %v", err)
+		logger.Fatal("failed to parse max retries from 'ROUTER_ROUND_TRIP_MAX_RETRIES'",
+			zap.Error(err),
+			zap.String("value", maxRetriesStr))
 	}

-	isDebugEnv, err := strconv.ParseBool(os.Getenv("DEBUG_ENV"))
+	isDebugEnvStr := os.Getenv("DEBUG_ENV")
+	isDebugEnv, err := strconv.ParseBool(isDebugEnvStr)
 	if err != nil {
-		log.Fatalf("Failed to parse DEBUG_ENV: %v", err)
+		logger.Fatal("failed to parse debug env from 'DEBUG_ENV'",
+			zap.Error(err),
+			zap.String("value", isDebugEnvStr))
 	}

 	// svcAddrRetryCount is the max times for RetryingRoundTripper to retry with a specific service address
-	svcAddrRetryCount, err := strconv.Atoi(os.Getenv("ROUTER_ROUND_TRIP_SVC_ADDRESS_MAX_RETRIES"))
+	svcAddrRetryCountStr := os.Getenv("ROUTER_ROUND_TRIP_SVC_ADDRESS_MAX_RETRIES")
+	svcAddrRetryCount, err := strconv.Atoi(svcAddrRetryCountStr)
 	if err != nil {
 		svcAddrRetryCount = 5
-		log.Printf("Failed to parse svc address retry conunt, set it to default value(5): %v", err)
+		logger.Info("failed to parse service address retry count from 'ROUTER_ROUND_TRIP_SVC_ADDRESS_MAX_RETRIES' - set to the default value",
+			zap.Error(err),
+			zap.String("value", svcAddrRetryCountStr),
+			zap.Int("default", svcAddrRetryCount))
 	}

 	// svcAddrUpdateTimeout is the timeout setting for a goroutine to wait for the update of a service entry.
 	// If the update process cannot be done within the timeout window, consider it failed.
+	svcAddrUpdateTimeoutStr := os.Getenv("ROUTER_ROUND_TRIP_SVC_ADDRESS_UPDATE_TIMEOUT")
 	svcAddrUpdateTimeout, err := time.ParseDuration(os.Getenv("ROUTER_ROUND_TRIP_SVC_ADDRESS_UPDATE_TIMEOUT"))
 	if err != nil {
 		svcAddrUpdateTimeout = 30 * time.Second
-		log.Printf("Failed to parse svc address update timeout, set it to default value(30): %v", err)
+		logger.Info("failed to parse service address update timeout duration from 'ROUTER_ROUND_TRIP_SVC_ADDRESS_UPDATE_TIMEOUT' - set to the default value",
+			zap.Error(err),
+			zap.String("value", svcAddrUpdateTimeoutStr),
+			zap.Duration("default", svcAddrUpdateTimeout))
 	}

-	triggers, _, fnStore := makeHTTPTriggerSet(fmap, frmap, trmap, fissionClient, kubeClient, executor, restClient, &tsRoundTripperParams{
+	triggers, _, fnStore := makeHTTPTriggerSet(logger.Named("triggerset"), fmap, frmap, trmap, fissionClient, kubeClient, executor, restClient, &tsRoundTripperParams{
 		timeout:           timeout,
 		timeoutExponent:   timeoutExponent,
 		keepAlive:         keepAlive,
@@ -162,10 +187,10 @@ func Start(port int, executorUrl string) {

 	resolver := makeFunctionReferenceResolver(fnStore)

-	go serveMetric()
+	go serveMetric(logger)

-	log.Printf("Starting router at port %v\n", port)
+	logger.Info("starting router", zap.Int("port", port))
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	serve(ctx, port, triggers, resolver)
+	serve(ctx, logger, port, triggers, resolver)
 }