Revert "feature/TRA_3427_demo_mode (#150)" (#151)

This reverts commit 71eff5ea04.

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/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/config.go

@@ -0,0 +1,34 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"github.com/up9inc/mizu/cli/mizu"
+	"github.com/up9inc/mizu/cli/uiUtils"
+	"io/ioutil"
+)
+
+var outputFileName string
+
+var configCmd = &cobra.Command{
+	Use:   "config",
+	Short: "Generate example config file to stdout",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		template := mizu.GetTemplateConfig()
+		if outputFileName != "" {
+			data := []byte(template)
+			_ = ioutil.WriteFile(outputFileName, data, 0644)
+			mizu.Log.Infof(fmt.Sprintf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, outputFileName)))
+		} else {
+			mizu.Log.Debugf("Writing template config.\n%v", template)
+			fmt.Printf("%v", template)
+		}
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(configCmd)
+
+	configCmd.Flags().StringVarP(&outputFileName, "file", "f", "", "Save content to local file")
+}

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/root.go

@@ -1,14 +1,32 @@
 package cmd
 
 import (
+	"errors"
+	"fmt"
 	"github.com/spf13/cobra"
+	"github.com/up9inc/mizu/cli/mizu"
 )
 
+var commandLineFlags []string
+
 var rootCmd = &cobra.Command{
 	Use:   "mizu",
 	Short: "A web traffic viewer for kubernetes",
 	Long: `A web traffic viewer for kubernetes
 Further info is available at https://github.com/up9inc/mizu`,
+	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+		if err := mizu.InitConfig(commandLineFlags); err != nil {
+			mizu.Log.Errorf("Invalid config, Exit %s", err)
+			return errors.New(fmt.Sprintf("%v", err))
+		}
+		prettifiedConfig := mizu.GetConfigStr()
+		mizu.Log.Debugf("Final Config: %s", prettifiedConfig)
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringSliceVar(&commandLineFlags, "set", []string{}, "Override values using --set")
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.

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
-to UP9 cloud 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]",
@@ -48,8 +46,15 @@ Supported protocols are HTTP and gRPC.`,
 		go mizu.ReportRun("tap", mizuTapOptions)
 		RunMizuTap(regex, mizuTapOptions)
 		return nil
+
 	},
 	PreRunE: func(cmd *cobra.Command, args []string) error {
+		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.Debugf(uiUtils.PrettyJson(mizuTapOptions))
+
 		if len(args) == 0 {
 			return errors.New("POD REGEX argument is required")
 		} else if len(args) > 1 {
@@ -67,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" {
@@ -80,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)
 			}
@@ -95,11 +100,8 @@ func init() {
 	tapCmd.Flags().Uint16VarP(&mizuTapOptions.GuiPort, "gui-port", "p", 8899, "Provide a custom port for the web interface webserver")
 	tapCmd.Flags().StringVarP(&mizuTapOptions.Namespace, "namespace", "n", "", "Namespace selector")
 	tapCmd.Flags().BoolVar(&mizuTapOptions.Analysis, "analysis", false, "Uploads traffic to UP9 for further analysis (Beta)")
-	tapCmd.Flags().StringVar(&mizuTapOptions.AnalysisDestination, "dest", "up9.app", "Destination environment")
-	tapCmd.Flags().Uint16VarP(&mizuTapOptions.SleepIntervalSec, "upload-interval", "", 10, "Interval in seconds for uploading data to UP9")
 	tapCmd.Flags().BoolVarP(&mizuTapOptions.AllNamespaces, "all-namespaces", "A", false, "Tap all namespaces")
 	tapCmd.Flags().StringVarP(&mizuTapOptions.KubeConfigPath, "kube-config", "k", "", "Path to kube-config file")
-	tapCmd.Flags().StringVarP(&mizuTapOptions.MizuImage, "mizu-image", "", fmt.Sprintf("gcr.io/up9-docker-hub/mizu/%s:%s", mizu.Branch, mizu.SemVer), "Custom image for mizu API server")
 	tapCmd.Flags().StringArrayVarP(&mizuTapOptions.PlainTextFilterRegexes, "regex-masking", "r", nil, "List of regex expressions that are used to filter matching values from text/plain http bodies")
 	tapCmd.Flags().StringVarP(&direction, "direction", "", "in", "Record traffic that goes in this direction (relative to the tapped pod): in/any")
 	tapCmd.Flags().BoolVar(&mizuTapOptions.HideHealthChecks, "hide-healthchecks", false, "hides requests with kube-probe or prometheus user-agent headers")

cli/cmd/tapRunner.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/up9inc/mizu/cli/kubernetes"
 	"github.com/up9inc/mizu/cli/mizu"
+	"github.com/up9inc/mizu/cli/uiUtils"
 	"github.com/up9inc/mizu/shared"
 	"github.com/up9inc/mizu/shared/debounce"
 	core "k8s.io/api/core/v1"
@@ -39,11 +40,11 @@ func RunMizuTap(podRegexQuery *regexp.Regexp, tappingOptions *MizuTapOptions) {
 	kubernetesProvider, err := kubernetes.NewProvider(tappingOptions.KubeConfigPath)
 	if err != nil {
 		if clientcmd.IsEmptyConfig(err) {
-			mizu.Log.Infof(mizu.Red, "Couldn't find the kube config file, or file is empty. Try adding '--kube-config=<path to kube config file>'\n")
+			mizu.Log.Infof(uiUtils.Red, "Couldn't find the kube config file, or file is empty. Try adding '--kube-config=<path to kube config file>'\n")
 			return
 		}
 		if clientcmd.IsConfigurationInvalid(err) {
-			mizu.Log.Infof(mizu.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>'\n")
 			return
 		}
 	}
@@ -66,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)
@@ -113,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
@@ -131,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
 	}
 
@@ -182,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
 		}
 	}
@@ -202,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
 		}
 	}
@@ -223,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)
 		}
 	}
 }
@@ -237,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
@@ -245,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()
 		}
 	}
@@ -259,10 +260,10 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro
 	for {
 		select {
 		case newTarget := <-added:
-			mizu.Log.Infof(mizu.Green, fmt.Sprintf("+%s\n", newTarget.Name))
+			mizu.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s", newTarget.Name))
 
 		case removedTarget := <-removed:
-			mizu.Log.Infof(mizu.Red, fmt.Sprintf("-%s\n", removedTarget.Name))
+			mizu.Log.Infof(uiUtils.Red, fmt.Sprintf("-%s", removedTarget.Name))
 			restartTappersDebouncer.SetOn()
 
 		case modifiedTarget := <-modified:
@@ -299,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:
@@ -308,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 {
@@ -323,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(mizu.Purple, "Traffic is uploading to UP9 for further analysis\n")
+						mizu.Log.Infof(uiUtils.Purple, "Traffic is uploading to UP9 for further analysis")
 					}
 				}
 			}
@@ -347,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
 		}
 	}
@@ -390,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()
 	}
 
@@ -401,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

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/up9inc/mizu/cli/kubernetes"
 	"github.com/up9inc/mizu/cli/mizu"
+	"github.com/up9inc/mizu/cli/uiUtils"
 	"k8s.io/client-go/tools/clientcmd"
 	"net/http"
 )
@@ -13,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(mizu.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
 		}
 	}
@@ -30,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/go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
 	github.com/spf13/cobra v1.1.3
 	github.com/up9inc/mizu/shared v0.0.0
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 	k8s.io/api v0.21.2
 	k8s.io/apimachinery v0.21.2
 	k8s.io/client-go v0.21.2

cli/go.sum

@@ -367,8 +367,6 @@ github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/romana/rlog v0.0.0-20171115192701-f018bc92e7d7 h1:jkvpcEatpwuMF5O5LVxTnehj6YZ/aEZN4NWD/Xml4pI=
-github.com/romana/rlog v0.0.0-20171115192701-f018bc92e7d7/go.mod h1:KTrHyWpO1sevuXPZwyeZc72ddWRFqNSKDFl7uVWKpg0=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
@@ -691,8 +689,9 @@ gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

cli/mizu/config.go

@@ -0,0 +1,221 @@
+package mizu
+
+import (
+	"errors"
+	"fmt"
+	"github.com/up9inc/mizu/cli/uiUtils"
+	"gopkg.in/yaml.v3"
+	"io/ioutil"
+	"os"
+	"path"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+const separator = "="
+
+var configObj = map[string]interface{}{}
+
+type CommandLineFlag struct {
+	CommandLineName   string
+	YamlHierarchyName string
+	DefaultValue      interface{}
+}
+
+const (
+	ConfigurationKeyAnalyzingDestination = "tap.dest"
+	ConfigurationKeyUploadInterval       = "tap.uploadInterval"
+	ConfigurationKeyMizuImage            = "mizuImage"
+	ConfigurationKeyTelemetry            = "telemetry"
+)
+
+var allowedSetFlags = []CommandLineFlag{
+	{
+		CommandLineName:   "dest",
+		YamlHierarchyName: ConfigurationKeyAnalyzingDestination,
+		DefaultValue:      "up9.app",
+		// TODO: maybe add short description that we can show
+	},
+	{
+		CommandLineName:   "uploadInterval",
+		YamlHierarchyName: ConfigurationKeyUploadInterval,
+		DefaultValue:      10,
+	},
+	{
+		CommandLineName:   "mizuImage",
+		YamlHierarchyName: ConfigurationKeyMizuImage,
+		DefaultValue:      fmt.Sprintf("gcr.io/up9-docker-hub/mizu/%s:%s", Branch, SemVer),
+	},
+	{
+		CommandLineName:   "telemetry",
+		YamlHierarchyName: ConfigurationKeyTelemetry,
+		DefaultValue:      true,
+	},
+}
+
+func GetString(key string) string {
+	return fmt.Sprintf("%v", getValueFromMergedConfig(key))
+}
+
+func GetBool(key string) bool {
+	stringVal := GetString(key)
+	Log.Debugf("Found string value %v", stringVal)
+
+	val, err := strconv.ParseBool(stringVal)
+	if err != nil {
+		Log.Warningf(uiUtils.Red, fmt.Sprintf( "Invalid value %v for key %s, expected bool", stringVal, key))
+		os.Exit(1)
+	}
+	return val
+}
+
+func GetInt(key string) int {
+	stringVal := GetString(key)
+	Log.Debugf("Found string value %v", stringVal)
+
+	val, err := strconv.Atoi(stringVal)
+	if err != nil {
+		Log.Warningf(uiUtils.Red, fmt.Sprintf("Invalid value %v for key %s, expected int", stringVal, key))
+		os.Exit(1)
+	}
+	return val
+}
+
+func InitConfig(commandLineValues []string) error {
+	Log.Debugf("Merging default values")
+	mergeDefaultValues()
+	Log.Debugf("Merging config file values")
+	if err1 := mergeConfigFile(); err1 != nil {
+		Log.Infof(fmt.Sprintf(uiUtils.Red, "Invalid config file\n"))
+		return err1
+	}
+	Log.Debugf("Merging command line values")
+	if err2 := mergeCommandLineFlags(commandLineValues); err2 != nil {
+		Log.Infof(fmt.Sprintf(uiUtils.Red, "Invalid commanad argument\n"))
+		return err2
+	}
+	finalConfigPrettified, _ := uiUtils.PrettyJson(configObj)
+	Log.Debugf("Merged all config successfully\n Final config: %v", finalConfigPrettified)
+	return nil
+}
+
+func GetTemplateConfig() string {
+	templateConfig := map[string]interface{}{}
+	for _, allowedFlag := range allowedSetFlags {
+		addToConfigObj(allowedFlag.YamlHierarchyName, allowedFlag.DefaultValue, templateConfig)
+	}
+	prettifiedConfig, _ := uiUtils.PrettyYaml(templateConfig)
+	return prettifiedConfig
+}
+
+func GetConfigStr() string {
+	val, _ := uiUtils.PrettyYaml(configObj)
+	return val
+}
+
+func getValueFromMergedConfig(key string) interface{} {
+	if a, ok := configObj[key]; ok {
+		return a
+	}
+	return nil
+}
+
+func mergeDefaultValues() {
+	for _, allowedFlag := range allowedSetFlags {
+		Log.Debugf("Setting %v to %v", allowedFlag.YamlHierarchyName, allowedFlag.DefaultValue)
+		configObj[allowedFlag.YamlHierarchyName] = allowedFlag.DefaultValue
+	}
+}
+
+func mergeConfigFile() error {
+	Log.Debugf("Merging mizu config file values")
+	home, homeDirErr := os.UserHomeDir()
+	if homeDirErr != nil {
+		return nil
+	}
+	reader, openErr := os.Open(path.Join(home, ".mizu", "config.yaml"))
+	if openErr != nil {
+		return nil
+	}
+	buf, readErr := ioutil.ReadAll(reader)
+	if readErr != nil {
+		return readErr
+	}
+	m := make(map[string]interface{})
+	if err := yaml.Unmarshal(buf, &m); err != nil {
+		return err
+	}
+	for k, v := range m {
+		addToConfig(k, v)
+	}
+	return nil
+}
+
+func addToConfig(prefix string, value interface{}) {
+	typ := reflect.TypeOf(value).Kind()
+	if typ == reflect.Map {
+		for k1, v1 := range value.(map[string]interface{}) {
+			addToConfig(fmt.Sprintf("%s.%s", prefix, k1), v1)
+		}
+	} else {
+		validateConfigFileKey(prefix)
+		configObj[prefix] = value
+	}
+}
+
+func mergeCommandLineFlags(commandLineValues []string) error {
+	Log.Debugf("Merging Command line flags")
+	for _, e := range commandLineValues {
+		if !strings.Contains(e, separator) {
+			return errors.New(fmt.Sprintf("invalid set argument %s", e))
+		}
+		split := strings.SplitN(e, separator, 2)
+		if len(split) != 2 {
+			return errors.New(fmt.Sprintf("invalid set argument %s", e))
+		}
+		setFlagKey, argumentValue := split[0], split[1]
+		argumentNameInConfig, err := flagFromAllowed(setFlagKey)
+		if err != nil {
+			return err
+		}
+
+		configObj[argumentNameInConfig] = argumentValue
+	}
+	return nil
+}
+
+func flagFromAllowed(setFlagKey string) (string, error) {
+	for _, allowedFlag := range allowedSetFlags {
+		if strings.ToLower(allowedFlag.CommandLineName) == strings.ToLower(setFlagKey) {
+			return allowedFlag.YamlHierarchyName, nil
+		}
+	}
+	return "", errors.New(fmt.Sprintf("invalid set argument %s", setFlagKey))
+}
+
+func validateConfigFileKey(configFileKey string) {
+	for _, allowedFlag := range allowedSetFlags {
+		if allowedFlag.YamlHierarchyName == configFileKey {
+			return
+		}
+	}
+	Log.Info(fmt.Sprintf("Unknown argument: %s. Exit", configFileKey))
+	os.Exit(1)
+}
+
+func addToConfigObj(key string, value interface{}, configObj map[string]interface{}) {
+	typ := reflect.TypeOf(value).Kind()
+	if typ != reflect.Map {
+		if strings.Contains(key, ".") {
+			split := strings.SplitN(key, ".", 2)
+			firstLevelKey := split[0]
+			if _, ok := configObj[firstLevelKey]; !ok {
+				configObj[firstLevelKey] = map[string]interface{}{}
+			}
+			addToConfigObj(split[1], value, configObj[firstLevelKey].(map[string]interface{}))
+		} else {
+			configObj[key] = value
+		}
+	}
+}

cli/mizu/consts.go

@@ -18,14 +18,3 @@ const (
 	TapperDaemonSetName    = "mizu-tapper-daemon-set"
 	TapperPodName          = "mizu-tapper"
 )
-
-const (
-	Black        = "\033[1;30m%s\033[0m"
-	Red          = "\033[1;31m%s\033[0m"
-	Green        = "\033[1;32m%s\033[0m"
-	Yellow       = "\033[1;33m%s\033[0m"
-	Purple       = "\033[1;34m%s\033[0m"
-	Magenta      = "\033[1;35m%s\033[0m"
-	Teal         = "\033[1;36m%s\033[0m"
-	White        = "\033[1;37m%s\033[0m"
-)

cli/mizu/logger.go

@@ -14,7 +14,7 @@ var format = logging.MustStringFormatter(
 )
 
 func InitLogger() {
-	homeDirPath, err := os.UserHomeDir()
+	homeDirPath, _ := os.UserHomeDir()
 	mizuDirPath := path.Join(homeDirPath, ".mizu")
 	if err := os.MkdirAll(mizuDirPath, os.ModePerm); err != nil {
 		panic(fmt.Sprintf("Failed creating .mizu dir: %v, err %v", mizuDirPath, err))

cli/mizu/telemetry.go

@@ -10,6 +10,11 @@ import (
 const telemetryUrl = "https://us-east4-up9-prod.cloudfunctions.net/mizu-telemetry"
 
 func ReportRun(cmd string, args interface{}) {
+	if !GetBool(ConfigurationKeyTelemetry) {
+		Log.Debugf("not reporting due to config value")
+		return
+	}
+
 	if Branch != "main" {
 		Log.Debugf("reporting only on main branch")
 		return
@@ -26,8 +31,7 @@ func ReportRun(cmd string, args interface{}) {
 
 	jsonValue, _ := json.Marshal(argsMap)
 
-	if resp, err := http.Post(telemetryUrl,
-		"application/json", bytes.NewBuffer(jsonValue)); err != nil {
+	if resp, err := http.Post(telemetryUrl, "application/json", bytes.NewBuffer(jsonValue)); err != nil {
 		Log.Debugf("error sending telemetry err: %v, response %v", err, resp)
 	} else {
 		Log.Debugf("Successfully reported telemetry")

cli/mizu/versionCheck.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/google/go-github/v37/github"
+	"github.com/up9inc/mizu/cli/uiUtils"
 	"github.com/up9inc/mizu/shared"
 	"github.com/up9inc/mizu/shared/semver"
 	"io/ioutil"
@@ -44,7 +45,7 @@ func CheckVersionCompatibility(port uint16) (bool, error) {
 		return true, nil
 	}
 
-	Log.Infof(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
 }
 
@@ -86,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(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))
 	}
 }

cli/uiUtils/colors.go

@@ -0,0 +1,13 @@
+package uiUtils
+
+
+const (
+	Black        = "\033[1;30m%s\033[0m"
+	Red          = "\033[1;31m%s\033[0m"
+	Green        = "\033[1;32m%s\033[0m"
+	Yellow       = "\033[1;33m%s\033[0m"
+	Purple       = "\033[1;34m%s\033[0m"
+	Magenta      = "\033[1;35m%s\033[0m"
+	Teal         = "\033[1;36m%s\033[0m"
+	White        = "\033[1;37m%s\033[0m"
+)

cli/uiUtils/confirmation.go

@@ -2,7 +2,7 @@ package uiUtils
 
 import (
 	"bufio"
-	"github.com/up9inc/mizu/cli/mizu"
+	"fmt"
 	"log"
 	"os"
 	"strings"
@@ -11,7 +11,7 @@ import (
 func AskForConfirmation(s string) bool {
 	reader := bufio.NewReader(os.Stdin)
 
-	mizu.Log.Infof(mizu.Magenta, s)
+	fmt.Printf(Magenta, s)
 
 	response, err := reader.ReadString('\n')
 	if err != nil {

cli/uiUtils/prettyString.go

@@ -0,0 +1,36 @@
+package uiUtils
+
+import (
+	"bytes"
+	"encoding/json"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	empty = ""
+	tab   = "\t"
+)
+
+func PrettyJson(data interface{}) (string, error) {
+	buffer := new(bytes.Buffer)
+	encoder := json.NewEncoder(buffer)
+	encoder.SetIndent(empty, tab)
+
+	err := encoder.Encode(data)
+	if err != nil {
+		return empty, err
+	}
+	return buffer.String(), nil
+}
+
+func PrettyYaml(data interface{}) (string, error) {
+	buffer := new(bytes.Buffer)
+	encoder := yaml.NewEncoder(buffer)
+	encoder.SetIndent(0)
+
+	err := encoder.Encode(data)
+	if err != nil {
+		return empty, err
+	}
+	return buffer.String(), nil
+}