feature/TRA_3427_demo_mode (#150)

* Demo Mode MVP

* messages improve

* downloading based on the OS

* downloading based on the OS

* downloading based on the OS

* Modeler keep running

* A lot of revisions comes now

* Fix color

README.md

@@ -1,6 +1,17 @@
-# 水 mizu
+![Mizu: The API Traffic Viewer for Kubernetes](assets/mizu-logo.svg)
+# The API Traffic Viewer for Kubernetes
+
 A simple-yet-powerful API traffic viewer for Kubernetes to help you troubleshoot and debug your microservices. Think TCPDump and Chrome Dev Tools combined.
 
+![Simple UI](assets/mizu-ui.png)
+
+## Features
+
+- Simple and powerful CLI
+- Real time view of all HTTP requests, REST and gRPC API calls
+- No installation or code instrumentation
+- Works completely on premises (on-prem)
+
 ## Download
 
 Download `mizu` for your platform and operating system
@@ -142,10 +153,10 @@ See `examples/roles` for example `clusterroles`.
 
 ## How to run
 
-1. Find pod you'd like to tap to in your Kubernetes cluster
+1. Find pods you'd like to tap to in your Kubernetes cluster
 2. Run `mizu tap PODNAME` or `mizu tap REGEX` 
-3. Open browser on `http://localhost:8899` as instructed .. 
-4. Watch the WebAPI traffic flowing ..
+3. Open browser on `http://localhost:8899/mizu` **or** as instructed in the CLI .. 
+4. Watch the API traffic flowing ..
 5. Type ^C to stop
 
 ## Examples

agent/main.go

@@ -4,12 +4,6 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
-	"github.com/gin-contrib/static"
-	"github.com/gin-gonic/gin"
-	"github.com/gorilla/websocket"
-	"github.com/romana/rlog"
-	"github.com/up9inc/mizu/shared"
-	"github.com/up9inc/mizu/tap"
 	"mizuserver/pkg/api"
 	"mizuserver/pkg/models"
 	"mizuserver/pkg/routes"
@@ -19,9 +13,17 @@ import (
 	"os"
 	"os/signal"
 	"strings"
+
+	"github.com/gin-contrib/static"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"github.com/romana/rlog"
+	"github.com/up9inc/mizu/shared"
+	"github.com/up9inc/mizu/tap"
 )
 
 var shouldTap = flag.Bool("tap", false, "Run in tapper mode without API")
+var demo = flag.Bool("demo", false, "Run in Demo mode with API")
 var apiServer = flag.Bool("api-server", false, "Run in API server mode with API")
 var standalone = flag.Bool("standalone", false, "Run in standalone tapper and API mode")
 var apiServerAddress = flag.String("api-server-address", "", "Address of mizu API server")
@@ -34,13 +36,12 @@ func main() {
 	if !*shouldTap && !*apiServer && !*standalone {
 		panic("One of the flags --tap, --api or --standalone must be provided")
 	}
-
 	if *standalone {
 		harOutputChannel, outboundLinkOutputChannel := tap.StartPassiveTapper(tapOpts)
 		filteredHarChannel := make(chan *tap.OutputChannelItem)
 
 		go filterHarItems(harOutputChannel, filteredHarChannel, getTrafficFilteringOptions())
-		go api.StartReadingEntries(filteredHarChannel, nil)
+		go api.StartReadingEntries(filteredHarChannel, nil, false)
 		go api.StartReadingOutbound(outboundLinkOutputChannel)
 
 		hostApi(nil)
@@ -69,7 +70,12 @@ func main() {
 		filteredHarChannel := make(chan *tap.OutputChannelItem)
 
 		go filterHarItems(socketHarOutChannel, filteredHarChannel, getTrafficFilteringOptions())
-		go api.StartReadingEntries(filteredHarChannel, nil)
+		if *demo {
+			workdir := "./hars"
+			go api.StartReadingEntries(filteredHarChannel, &workdir, true)
+		} else {
+			go api.StartReadingEntries(filteredHarChannel, nil, false)
+		}
 
 		hostApi(socketHarOutChannel)
 	}

agent/pkg/api/main.go

@@ -5,10 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/google/martian/har"
-	"github.com/romana/rlog"
-	"github.com/up9inc/mizu/tap"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"math/rand"
 	"mizuserver/pkg/holder"
 	"net/url"
 	"os"
@@ -17,6 +14,11 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/martian/har"
+	"github.com/romana/rlog"
+	"github.com/up9inc/mizu/tap"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+
 	"mizuserver/pkg/database"
 	"mizuserver/pkg/models"
 	"mizuserver/pkg/resolver"
@@ -47,15 +49,15 @@ func init() {
 	holder.SetResolver(res)
 }
 
-func StartReadingEntries(harChannel <-chan *tap.OutputChannelItem, workingDir *string) {
+func StartReadingEntries(harChannel <-chan *tap.OutputChannelItem, workingDir *string, demo bool) {
 	if workingDir != nil && *workingDir != "" {
-		startReadingFiles(*workingDir)
+		startReadingFiles(*workingDir, demo)
 	} else {
 		startReadingChannel(harChannel)
 	}
 }
 
-func startReadingFiles(workingDir string) {
+func startReadingFiles(workingDir string, infiniteLoad bool) {
 	err := os.MkdirAll(workingDir, os.ModePerm)
 	utils.CheckErr(err)
 
@@ -86,18 +88,23 @@ func startReadingFiles(workingDir string) {
 		utils.CheckErr(decErr)
 
 		for _, entry := range inputHar.Log.Entries {
-			time.Sleep(time.Millisecond * 250)
+			if infiniteLoad {
+				entry.StartedDateTime = time.Now().Add(20 * time.Millisecond)
+			}
+			time.Sleep(time.Millisecond * time.Duration(rand.Intn(300)))
 			connectionInfo := &tap.ConnectionInfo{
-				ClientIP: fileInfo.Name(),
+				ClientIP:   fileInfo.Name(),
 				ClientPort: "",
-				ServerIP: "",
+				ServerIP:   "",
 				ServerPort: "",
 				IsOutgoing: false,
 			}
 			saveHarToDb(entry, connectionInfo)
 		}
-		rmErr := os.Remove(inputFilePath)
-		utils.CheckErr(rmErr)
+		if !infiniteLoad {
+			rmErr := os.Remove(inputFilePath)
+			utils.CheckErr(rmErr)
+		}
 	}
 }
 
@@ -118,7 +125,6 @@ func StartReadingOutbound(outboundLinkChannel <-chan *tap.OutboundLink) {
 	}
 }
 
-
 func saveHarToDb(entry *har.Entry, connectionInfo *tap.ConnectionInfo) {
 	entryBytes, _ := json.Marshal(entry)
 	serviceName, urlPath := getServiceNameFromUrl(entry.Request.URL)
@@ -196,6 +202,5 @@ func getEstimatedEntrySizeBytes(mizuEntry models.MizuEntry) int {
 	sizeBytes += 8 // SizeBytes bytes
 	sizeBytes += 1 // IsOutgoing bytes
 
-
 	return sizeBytes
 }

agent/pkg/api/socket_server_handlers.go

@@ -27,9 +27,9 @@ func init() {
 
 func (h *RoutesEventHandlers) WebSocketConnect(socketId int, isTapper bool) {
 	if isTapper {
-		rlog.Infof("Websocket Connection event - Tapper connected: %s", socketId)
+		rlog.Infof("Websocket event - Tapper connected, socket ID: %d", socketId)
 	} else {
-		rlog.Infof("Websocket Connection event - Browser socket connected: %s", socketId)
+		rlog.Infof("Websocket event - Browser socket connected, socket ID: %d", socketId)
 		socketListLock.Lock()
 		browserClientSocketUUIDs = append(browserClientSocketUUIDs, socketId)
 		socketListLock.Unlock()
@@ -38,9 +38,9 @@ func (h *RoutesEventHandlers) WebSocketConnect(socketId int, isTapper bool) {
 
 func (h *RoutesEventHandlers) WebSocketDisconnect(socketId int, isTapper bool) {
 	if isTapper {
-		rlog.Infof("Disconnection event - Tapper connected: %s", socketId)
+		rlog.Infof("Websocket event - Tapper disconnected, socket ID:  %d", socketId)
 	} else {
-		rlog.Infof("Disconnection event - Browser socket connected: %s", socketId)
+		rlog.Infof("Websocket event - Browser socket disconnected, socket ID:  %d", socketId)
 		socketListLock.Lock()
 		removeSocketUUIDFromBrowserSlice(socketId)
 		socketListLock.Unlock()
@@ -52,7 +52,7 @@ func broadcastToBrowserClients(message []byte) {
 		go func(socketId int) {
 			err := routes.SendToSocket(socketId, message)
 			if err != nil {
-				fmt.Printf("error sending message to socket id %d: %v", socketId, err)
+				fmt.Printf("error sending message to socket ID %d: %v", socketId, err)
 			}
 		}(socketId)
 

cli/cmd/demo.go

@@ -0,0 +1,32 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+type MizuDemoOptions struct {
+	GuiPort            uint16
+	Analyze            bool
+	AnalyzeDestination string
+}
+
+var mizuDemoOptions = &MizuDemoOptions{}
+
+var demoCmd = &cobra.Command{
+	Use:   "demo",
+	Short: "Record ingoing traffic of a kubernetes pod",
+	Long: `Record the ingoing traffic of a kubernetes pod.
+Supported protocols are HTTP and gRPC.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		RunMizuTapDemo(mizuDemoOptions)
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(demoCmd)
+
+	demoCmd.Flags().Uint16VarP(&mizuDemoOptions.GuiPort, "gui-port", "p", 8899, "Provide a custom port for the web interface webserver")
+	demoCmd.Flags().BoolVar(&mizuDemoOptions.Analyze, "analyze", false, "Uploads traffic to UP9 cloud for further analysis (Beta)")
+	demoCmd.Flags().StringVar(&mizuDemoOptions.AnalyzeDestination, "dest", "up9.app", "Destination environment")
+}

cli/cmd/demoRunner.go

@@ -0,0 +1,185 @@
+package cmd
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/up9inc/mizu/cli/uiUtils"
+)
+
+func RunMizuTapDemo(demoOptions *MizuDemoOptions) {
+	dir, _ := os.Getwd()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	downloadMizuDemo(dir)
+
+	go callMizuDemo(ctx, cancel, dir, demoOptions)
+	if demoOptions.Analyze {
+		go analyze(demoOptions)
+		fmt.Printf(uiUtils.Purple, "mizu tap \"catalogue-.*|carts-[0-9].*|payment.*|shipping.*|user-[0-9].*\" -n sock-shop --analyze\n")
+	} else {
+		fmt.Printf(uiUtils.Purple, "mizu tap \"catalogue-.*|carts-[0-9].*|payment.*|shipping.*|user-[0-9].*\" -n sock-shop\n")
+	}
+	fmt.Println("Mizu will be available on http://localhost:8899 in a few seconds")
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+
+	select {
+	case <-ctx.Done():
+		break
+	case <-sigChan:
+		cleanUpDemoResources(dir)
+		cancel()
+	}
+}
+
+func cleanUpDemoResources(dir string) {
+	removeFile(fmt.Sprintf("%s/site.zip", dir))
+	removeFile(fmt.Sprintf("%s/site", dir))
+	removeFile(fmt.Sprintf("%s/apiserver.zip", dir))
+	removeFile(fmt.Sprintf("%s/apiserver", dir))
+	removeFile(fmt.Sprintf("%s/entries.db", dir))
+	removeFile(fmt.Sprintf("%s/hars", dir))
+	removeFile(fmt.Sprintf("%s/hars.zip", dir))
+}
+
+func removeFile(file string) {
+	err := os.RemoveAll(file)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func downloadMizuDemo(dir string) {
+	if runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
+		panic("Platform not supported")
+	}
+	mizuApiURL := fmt.Sprintf("https://storage.googleapis.com/up9-mizu-demo-mode/apiserver-%s.zip", runtime.GOOS)
+	siteFileURL := "https://storage.googleapis.com/up9-mizu-demo-mode/site.zip"
+	harsURL := "https://storage.googleapis.com/up9-mizu-demo-mode/hars.zip"
+
+	dirApi := fmt.Sprintf("%s/apiserver.zip", dir)
+	dirSite := fmt.Sprintf("%s/site.zip", dir)
+	dirHars := fmt.Sprintf("%s/hars.zip", dir)
+
+	DownloadFile(dirApi, mizuApiURL)
+	DownloadFile(dirSite, siteFileURL)
+	DownloadFile(dirHars, harsURL)
+
+	UnzipSite(dirSite, fmt.Sprintf("%s/", dir))
+	UnzipSite(dirApi, fmt.Sprintf("%s/", dir))
+	UnzipSite(dirHars, fmt.Sprintf("%s/", dir))
+	allowExecutable(fmt.Sprintf("%s/apiserver", dir))
+}
+
+func DownloadFile(filepath string, url string) error {
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	out, err := os.Create(filepath)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+	_, err = io.Copy(out, resp.Body)
+	return err
+}
+
+func UnzipSite(src string, dest string) ([]string, error) {
+	var filenames []string
+
+	r, err := zip.OpenReader(src)
+	if err != nil {
+		return filenames, err
+	}
+	defer r.Close()
+
+	for _, f := range r.File {
+
+		fpath := filepath.Join(dest, f.Name)
+		if !strings.HasPrefix(fpath, filepath.Clean(dest)+string(os.PathSeparator)) {
+			return filenames, fmt.Errorf("%s: illegal file path", fpath)
+		}
+
+		filenames = append(filenames, fpath)
+
+		if f.FileInfo().IsDir() {
+			os.MkdirAll(fpath, os.ModePerm)
+			continue
+		}
+		if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
+			return filenames, err
+		}
+
+		outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
+		if err != nil {
+			return filenames, err
+		}
+
+		rc, err := f.Open()
+		if err != nil {
+			return filenames, err
+		}
+
+		_, err = io.Copy(outFile, rc)
+		outFile.Close()
+		rc.Close()
+
+		if err != nil {
+			return filenames, err
+		}
+	}
+	return filenames, nil
+}
+
+func allowExecutable(dir string) {
+	if err := os.Chmod(dir, 0755); err != nil {
+		log.Fatalln(err)
+	}
+}
+
+func callMizuDemo(ctx context.Context, cancel context.CancelFunc, dir string, demoOptions *MizuDemoOptions) {
+	cmd := exec.Command(fmt.Sprintf("%s/apiserver", dir), "--aggregator", "--demo")
+	var out bytes.Buffer
+
+	// set the output to our variable
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		log.Println(err)
+	}
+}
+
+func analyze(demoOptions *MizuDemoOptions) {
+	mizuProxiedUrl := getMizuCollectorProxiedHostAndPath(demoOptions.GuiPort)
+	for {
+		response, err := http.Get(fmt.Sprintf("http://%s/api/uploadEntries?dest=%s&interval=10", mizuProxiedUrl, demoOptions.AnalyzeDestination))
+		if err != nil || response.StatusCode != 200 {
+			fmt.Printf(uiUtils.Red, "Mizu Not running, waiting 10 seconds before trying again\n")
+		} else {
+			fmt.Printf(uiUtils.Purple, "Traffic is uploading to UP9 cloud for further analsys\n")
+			break
+		}
+		time.Sleep(10 * time.Second)
+	}
+}
+
+func getMizuCollectorProxiedHostAndPath(mizuPort uint16) string {
+	return fmt.Sprintf("localhost:%d", mizuPort)
+}

cli/cmd/fetch.go

@@ -18,7 +18,7 @@ var fetchCmd = &cobra.Command{
 	Use:   "fetch",
 	Short: "Download recorded traffic to files",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		go mizu.ReportRun("tap", mizuTapOptions)
+		go mizu.ReportRun("fetch", mizuTapOptions)
 		if isCompatible, err := mizu.CheckVersionCompatibility(mizuFetchOptions.MizuPort); err != nil {
 			return err
 		} else if !isCompatible {

cli/cmd/tap.go

@@ -35,9 +35,7 @@ var regex *regexp.Regexp
 
 const maxEntriesDBSizeFlagName = "max-entries-db-size"
 
-const analysisMessageToConfirm = `NOTE: running mizu with --analysis flag will upload recorded traffic 
-for further analysis and enriched presentation options.
-`
+const analysisMessageToConfirm = `NOTE: running mizu with --analysis flag will upload recorded traffic for further analysis and enriched presentation options.`
 
 var tapCmd = &cobra.Command{
 	Use:   "tap [POD REGEX]",
@@ -51,12 +49,11 @@ Supported protocols are HTTP and gRPC.`,
 
 	},
 	PreRunE: func(cmd *cobra.Command, args []string) error {
-		mizu.Log.Info("Getting params")
+		mizu.Log.Debugf("Getting params")
 		mizuTapOptions.AnalysisDestination = mizu.GetString(mizu.ConfigurationKeyAnalyzingDestination)
 		mizuTapOptions.SleepIntervalSec = uint16(mizu.GetInt(mizu.ConfigurationKeyUploadInterval))
 		mizuTapOptions.MizuImage = mizu.GetString(mizu.ConfigurationKeyMizuImage)
-		mizu.Log.Infof(uiUtils.PrettyJson(mizuTapOptions))
-
+		mizu.Log.Debugf(uiUtils.PrettyJson(mizuTapOptions))
 
 		if len(args) == 0 {
 			return errors.New("POD REGEX argument is required")
@@ -75,7 +72,7 @@ Supported protocols are HTTP and gRPC.`,
 		if parseHumanDataSizeErr != nil {
 			return errors.New(fmt.Sprintf("Could not parse --max-entries-db-size value %s", humanMaxEntriesDBSize))
 		}
-		mizu.Log.Infof("Mizu will store up to %s of traffic, old traffic will be cleared once the limit is reached.\n", units.BytesToHumanReadable(mizuTapOptions.MaxEntriesDBSizeBytes))
+		mizu.Log.Infof("Mizu will store up to %s of traffic, old traffic will be cleared once the limit is reached.", units.BytesToHumanReadable(mizuTapOptions.MaxEntriesDBSizeBytes))
 
 		directionLowerCase := strings.ToLower(direction)
 		if directionLowerCase == "any" {
@@ -88,7 +85,7 @@ Supported protocols are HTTP and gRPC.`,
 
 		if mizuTapOptions.Analysis {
 			mizu.Log.Infof(analysisMessageToConfirm)
-			if !uiUtils.AskForConfirmation("Would you like to proceed [y/n]: ") {
+			if !uiUtils.AskForConfirmation("Would you like to proceed [Y/n]: ") {
 				mizu.Log.Infof("You can always run mizu without analysis, aborting")
 				os.Exit(0)
 			}

cli/cmd/tapRunner.go

@@ -67,14 +67,14 @@ func RunMizuTap(podRegexQuery *regexp.Regexp, tappingOptions *MizuTapOptions) {
 	} else {
 		namespacesStr = "all namespaces"
 	}
-	mizu.Log.Infof("Tapping pods in %s\n", namespacesStr)
+	mizu.Log.Infof("Tapping pods in %s", namespacesStr)
 
 	if len(currentlyTappedPods) == 0 {
 		var suggestionStr string
 		if targetNamespace != mizu.K8sAllNamespaces {
 			suggestionStr = "\nSelect a different namespace with -n or tap all namespaces with -A"
 		}
-		mizu.Log.Infof("Did not find any pods matching the regex argument%s\n", suggestionStr)
+		mizu.Log.Infof("Did not find any pods matching the regex argument%s", suggestionStr)
 	}
 
 	nodeToTappedPodIPMap, err := getNodeHostToTappedPodIpsMap(currentlyTappedPods)
@@ -114,7 +114,7 @@ func createMizuResources(ctx context.Context, kubernetesProvider *kubernetes.Pro
 func createMizuNamespace(ctx context.Context, kubernetesProvider *kubernetes.Provider) error {
 	_, err := kubernetesProvider.CreateNamespace(ctx, mizu.ResourcesNamespace)
 	if err != nil {
-		mizu.Log.Infof("Error creating Namespace %s: %v\n", mizu.ResourcesNamespace, err)
+		mizu.Log.Infof("Error creating Namespace %s: %v", mizu.ResourcesNamespace, err)
 	}
 
 	return err
@@ -132,13 +132,13 @@ func createMizuApiServer(ctx context.Context, kubernetesProvider *kubernetes.Pro
 	}
 	_, err = kubernetesProvider.CreateMizuApiServerPod(ctx, mizu.ResourcesNamespace, mizu.ApiServerPodName, tappingOptions.MizuImage, serviceAccountName, mizuApiFilteringOptions, tappingOptions.MaxEntriesDBSizeBytes)
 	if err != nil {
-		mizu.Log.Infof("Error creating mizu %s pod: %v\n", mizu.ApiServerPodName, err)
+		mizu.Log.Infof("Error creating mizu %s pod: %v", mizu.ApiServerPodName, err)
 		return err
 	}
 
 	apiServerService, err = kubernetesProvider.CreateService(ctx, mizu.ResourcesNamespace, mizu.ApiServerPodName, mizu.ApiServerPodName)
 	if err != nil {
-		mizu.Log.Infof("Error creating mizu %s service: %v\n", mizu.ApiServerPodName, err)
+		mizu.Log.Infof("Error creating mizu %s service: %v", mizu.ApiServerPodName, err)
 		return err
 	}
 
@@ -183,12 +183,12 @@ func updateMizuTappers(ctx context.Context, kubernetesProvider *kubernetes.Provi
 			serviceAccountName,
 			tappingOptions.TapOutgoing,
 		); err != nil {
-			mizu.Log.Infof("Error creating mizu tapper daemonset: %v\n", err)
+			mizu.Log.Infof("Error creating mizu tapper daemonset: %v", err)
 			return err
 		}
 	} else {
 		if err := kubernetesProvider.RemoveDaemonSet(ctx, mizu.ResourcesNamespace, mizu.TapperDaemonSetName); err != nil {
-			mizu.Log.Infof("Error deleting mizu tapper daemonset: %v\n", err)
+			mizu.Log.Infof("Error deleting mizu tapper daemonset: %v", err)
 			return err
 		}
 	}
@@ -203,13 +203,13 @@ func cleanUpMizuResources(kubernetesProvider *kubernetes.Provider) {
 	defer cancel()
 
 	if err := kubernetesProvider.RemoveNamespace(removalCtx, mizu.ResourcesNamespace); err != nil {
-		mizu.Log.Infof("Error removing Namespace %s: %s (%v,%+v)\n", mizu.ResourcesNamespace, err, err, err)
+		mizu.Log.Infof("Error removing Namespace %s: %s (%v,%+v)", mizu.ResourcesNamespace, err, err, err)
 		return
 	}
 
 	if mizuServiceAccountExists {
 		if err := kubernetesProvider.RemoveNonNamespacedResources(removalCtx, mizu.ClusterRoleName, mizu.ClusterRoleBindingName); err != nil {
-			mizu.Log.Infof("Error removing non-namespaced resources: %s (%v,%+v)\n", err, err, err)
+			mizu.Log.Infof("Error removing non-namespaced resources: %s (%v,%+v)", err, err, err)
 			return
 		}
 	}
@@ -224,9 +224,9 @@ func cleanUpMizuResources(kubernetesProvider *kubernetes.Provider) {
 		case removalCtx.Err() == context.Canceled:
 			// Do nothing. User interrupted the wait.
 		case err == wait.ErrWaitTimeout:
-			mizu.Log.Infof("Timeout while removing Namespace %s\n", mizu.ResourcesNamespace)
+			mizu.Log.Infof("Timeout while removing Namespace %s", mizu.ResourcesNamespace)
 		default:
-			mizu.Log.Infof("Error while waiting for Namespace %s to be deleted: %s (%v,%+v)\n", mizu.ResourcesNamespace, err, err, err)
+			mizu.Log.Infof("Error while waiting for Namespace %s to be deleted: %s (%v,%+v)", mizu.ResourcesNamespace, err, err, err)
 		}
 	}
 }
@@ -238,7 +238,7 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro
 
 	restartTappers := func() {
 		if matchingPods, err := kubernetesProvider.GetAllPodsMatchingRegex(ctx, podRegex, targetNamespace); err != nil {
-			mizu.Log.Infof("Error getting pods by regex: %s (%v,%+v)\n", err, err, err)
+			mizu.Log.Infof("Error getting pods by regex: %s (%v,%+v)", err, err, err)
 			cancel()
 		} else {
 			currentlyTappedPods = matchingPods
@@ -246,12 +246,12 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro
 
 		nodeToTappedPodIPMap, err := getNodeHostToTappedPodIpsMap(currentlyTappedPods)
 		if err != nil {
-			mizu.Log.Infof("Error building node to ips map: %s (%v,%+v)\n", err, err, err)
+			mizu.Log.Infof("Error building node to ips map: %s (%v,%+v)", err, err, err)
 			cancel()
 		}
 
 		if err := updateMizuTappers(ctx, kubernetesProvider, nodeToTappedPodIPMap, tappingOptions); err != nil {
-			mizu.Log.Infof("Error updating daemonset: %s (%v,%+v)\n", err, err, err)
+			mizu.Log.Infof("Error updating daemonset: %s (%v,%+v)", err, err, err)
 			cancel()
 		}
 	}
@@ -260,10 +260,10 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro
 	for {
 		select {
 		case newTarget := <-added:
-			mizu.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s\n", newTarget.Name))
+			mizu.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s", newTarget.Name))
 
 		case removedTarget := <-removed:
-			mizu.Log.Infof(uiUtils.Red, fmt.Sprintf("-%s\n", removedTarget.Name))
+			mizu.Log.Infof(uiUtils.Red, fmt.Sprintf("-%s", removedTarget.Name))
 			restartTappersDebouncer.SetOn()
 
 		case modifiedTarget := <-modified:
@@ -300,7 +300,7 @@ func portForwardApiPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 		case <-added:
 			continue
 		case <-removed:
-			mizu.Log.Infof("%s removed\n", mizu.ApiServerPodName)
+			mizu.Log.Infof("%s removed", mizu.ApiServerPodName)
 			cancel()
 			return
 		case modifiedPod := <-modified:
@@ -309,12 +309,12 @@ func portForwardApiPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 				go func() {
 					err := kubernetes.StartProxy(kubernetesProvider, tappingOptions.GuiPort, mizu.ResourcesNamespace, mizu.ApiServerPodName)
 					if err != nil {
-						mizu.Log.Infof("Error occured while running k8s proxy %v\n", err)
+						mizu.Log.Infof("Error occured while running k8s proxy %v", err)
 						cancel()
 					}
 				}()
 				mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(tappingOptions.GuiPort)
-				mizu.Log.Infof("Mizu is available at http://%s\n", mizuProxiedUrl)
+				mizu.Log.Infof("Mizu is available at http://%s", mizuProxiedUrl)
 
 				time.Sleep(time.Second * 5) // Waiting to be sure the proxy is ready
 				if tappingOptions.Analysis {
@@ -324,11 +324,11 @@ func portForwardApiPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 					if err != nil {
 						log.Fatal(fmt.Sprintf("Failed parsing the URL %v\n", err))
 					}
-					mizu.Log.Debugf("Sending get request to %v\n", u.String())
+					mizu.Log.Debugf("Sending get request to %v", u.String())
 					if response, err := http.Get(u.String()); err != nil || response.StatusCode != 200 {
-						mizu.Log.Infof("error sending upload entries req, status code: %v, err: %v\n", response.StatusCode, err)
+						mizu.Log.Infof("error sending upload entries req, status code: %v, err: %v", response.StatusCode, err)
 					} else {
-						mizu.Log.Infof(uiUtils.Purple, "Traffic is uploading to UP9 for further analysis\n")
+						mizu.Log.Infof(uiUtils.Purple, "Traffic is uploading to UP9 for further analysis")
 					}
 				}
 			}
@@ -348,13 +348,13 @@ func portForwardApiPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 func createRBACIfNecessary(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
 	mizuRBACExists, err := kubernetesProvider.DoesServiceAccountExist(ctx, mizu.ResourcesNamespace, mizu.ServiceAccountName)
 	if err != nil {
-		mizu.Log.Infof("warning: could not ensure mizu rbac resources exist %v\n", err)
+		mizu.Log.Infof("warning: could not ensure mizu rbac resources exist %v", err)
 		return false
 	}
 	if !mizuRBACExists {
 		err := kubernetesProvider.CreateMizuRBAC(ctx, mizu.ResourcesNamespace, mizu.ServiceAccountName, mizu.ClusterRoleName, mizu.ClusterRoleBindingName, mizu.RBACVersion)
 		if err != nil {
-			mizu.Log.Infof("warning: could not create mizu rbac resources %v\n", err)
+			mizu.Log.Infof("warning: could not create mizu rbac resources %v", err)
 			return false
 		}
 	}
@@ -391,7 +391,7 @@ func syncApiStatus(ctx context.Context, cancel context.CancelFunc, tappingOption
 	controlSocketStr := fmt.Sprintf("ws://%s/ws", kubernetes.GetMizuApiServerProxiedHostAndPath(tappingOptions.GuiPort))
 	controlSocket, err := mizu.CreateControlSocket(controlSocketStr)
 	if err != nil {
-		mizu.Log.Infof("error establishing control socket connection %s\n", err)
+		mizu.Log.Infof("error establishing control socket connection %s", err)
 		cancel()
 	}
 
@@ -402,7 +402,7 @@ func syncApiStatus(ctx context.Context, cancel context.CancelFunc, tappingOption
 		default:
 			err = controlSocket.SendNewTappedPodsListMessage(currentlyTappedPods)
 			if err != nil {
-				mizu.Log.Debugf("error Sending message via control socket %v, error: %s\n", controlSocketStr, err)
+				mizu.Log.Debugf("error Sending message via control socket %v, error: %s", controlSocketStr, err)
 			}
 			time.Sleep(10 * time.Second)
 		}

cli/cmd/version.go

@@ -20,11 +20,11 @@ var versionCmd = &cobra.Command{
 		go mizu.ReportRun("version", mizuVersionOptions)
 		if mizuVersionOptions.DebugInfo {
 			timeStampInt, _ := strconv.ParseInt(mizu.BuildTimestamp, 10, 0)
-			mizu.Log.Infof("Version: %s \nBranch: %s (%s) \n", mizu.SemVer, mizu.Branch, mizu.GitCommitHash)
-			mizu.Log.Infof("Build Time: %s (%s)\n", mizu.BuildTimestamp, time.Unix(timeStampInt, 0))
+			mizu.Log.Infof("Version: %s \nBranch: %s (%s)", mizu.SemVer, mizu.Branch, mizu.GitCommitHash)
+			mizu.Log.Infof("Build Time: %s (%s)", mizu.BuildTimestamp, time.Unix(timeStampInt, 0))
 
 		} else {
-			mizu.Log.Infof("Version: %s (%s)\n", mizu.SemVer, mizu.Branch)
+			mizu.Log.Infof("Version: %s (%s)", mizu.SemVer, mizu.Branch)
 		}
 		return nil
 	},

cli/cmd/viewRunner.go

@@ -14,11 +14,11 @@ func runMizuView(mizuViewOptions *MizuViewOptions) {
 	kubernetesProvider, err := kubernetes.NewProvider(mizuViewOptions.KubeConfigPath)
 	if err != nil {
 		if clientcmd.IsEmptyConfig(err) {
-			mizu.Log.Infof("Couldn't find the kube config file, or file is empty. Try adding '--kube-config=<path to kube config file>'\n")
+			mizu.Log.Infof("Couldn't find the kube config file, or file is empty. Try adding '--kube-config=<path to kube config file>'")
 			return
 		}
 		if clientcmd.IsConfigurationInvalid(err) {
-			mizu.Log.Infof(uiUtils.Red, "Invalid kube config file. Try using a different config with '--kube-config=<path to kube config file>'\n")
+			mizu.Log.Infof(uiUtils.Red, "Invalid kube config file. Try using a different config with '--kube-config=<path to kube config file>'")
 			return
 		}
 	}
@@ -31,21 +31,21 @@ func runMizuView(mizuViewOptions *MizuViewOptions) {
 		panic(err)
 	}
 	if !exists {
-		mizu.Log.Infof("The %s service not found\n", mizu.ApiServerPodName)
+		mizu.Log.Infof("The %s service not found", mizu.ApiServerPodName)
 		return
 	}
 
 	mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(mizuViewOptions.GuiPort)
 	_, err = http.Get(fmt.Sprintf("http://%s/", mizuProxiedUrl))
 	if err == nil {
-		mizu.Log.Infof("Found a running service %s and open port %d\n", mizu.ApiServerPodName, mizuViewOptions.GuiPort)
+		mizu.Log.Infof("Found a running service %s and open port %d", mizu.ApiServerPodName, mizuViewOptions.GuiPort)
 		return
 	}
-	mizu.Log.Infof("Found service %s, creating k8s proxy\n", mizu.ApiServerPodName)
+	mizu.Log.Infof("Found service %s, creating k8s proxy", mizu.ApiServerPodName)
 
 	mizu.Log.Infof("Mizu is available at  http://%s\n", kubernetes.GetMizuApiServerProxiedHostAndPath(mizuViewOptions.GuiPort))
 	err = kubernetes.StartProxy(kubernetesProvider, mizuViewOptions.GuiPort, mizu.ResourcesNamespace, mizu.ApiServerPodName)
 	if err != nil {
-		mizu.Log.Infof("Error occured while running k8s proxy %v\n", err)
+		mizu.Log.Infof("Error occured while running k8s proxy %v", err)
 	}
 }

cli/mizu/versionCheck.go

@@ -45,7 +45,7 @@ func CheckVersionCompatibility(port uint16) (bool, error) {
 		return true, nil
 	}
 
-	Log.Infof(uiUtils.Red, fmt.Sprintf("cli version (%s) is not compatible with api version (%s)\n", SemVer, apiSemVer))
+	Log.Infof(uiUtils.Red, fmt.Sprintf("cli version (%s) is not compatible with api version (%s)", SemVer, apiSemVer))
 	return false, nil
 }
 
@@ -87,6 +87,6 @@ func CheckNewerVersion() {
 	gitHubVersion = gitHubVersion[:len(gitHubVersion)-1]
 	Log.Debugf("Finished version validation, took %v", time.Since(start))
 	if SemVer < gitHubVersion {
-		Log.Infof(uiUtils.Yellow, fmt.Sprintf("Update available! %v -> %v (%v)\n", SemVer, gitHubVersion, *latestRelease.HTMLURL))
+		Log.Infof(uiUtils.Yellow, fmt.Sprintf("Update available! %v -> %v (%v)", SemVer, gitHubVersion, *latestRelease.HTMLURL))
 	}
 }