print warnings with --warnings flag (#1001)

* warnings flag supresses warning messages

* formatting fixes

* fix tests

Author: jasonhawkharris

cmd/src/scout_advise.go

@@ -31,6 +31,9 @@ func init() {
 
         Output advice to file
         $ src scout advise --o path/to/file
+
+        Output with warnings
+        $ src scout advise --warnings
     `
 
 	flagSet := flag.NewFlagSet("advise", flag.ExitOnError)
@@ -45,6 +48,7 @@ func init() {
 		namespace  = flagSet.String("namespace", "", "(optional) specify the kubernetes namespace to use")
 		pod        = flagSet.String("pod", "", "(optional) specify a single pod")
 		output     = flagSet.String("o", "", "(optional) output advice to file")
+		warnings   = flagSet.Bool("warnings", false, "(optional) output advice with warnings")
 	)
 
 	if home := homedir.HomeDir(); home != "" {
@@ -88,6 +92,9 @@ func init() {
 		if *output != "" {
 			options = append(options, advise.WithOutput(*output))
 		}
+		if *warnings {
+			options = append(options, advise.WithWarnings(true))
+		}
 
 		return advise.K8s(
 			context.Background(),
@@ -103,5 +110,4 @@ func init() {
 		handler:   handler,
 		usageFunc: usage,
 	})
-
 }

internal/scout/advise/advise.go

@@ -12,10 +12,9 @@ import (
 type Option = func(config *scout.Config)
 
 const (
-	OVER_100 = "\t%s %s: Your %s usage is over 100%% (%.2f%%). Add more %s."
-	OVER_80  = "\t%s %s: Your %s usage is over 80%% (%.2f%%). Consider raising limits."
-	OVER_40  = "\t%s %s: Your %s usage is under 80%% (%.2f%%). Keep %s allocation the same."
-	UNDER_40 = "\t%s %s: Your %s usage is under 40%% (%.2f%%). Consider lowering limits."
+	UNDER_PROVISIONED = "%s %s: %s is under-provisioned (%.2f%% usage). Add resources."
+	WELL_PROVISIONED  = "%s %s: %s is well-provisioned (%.2f%% usage). No action needed."
+	OVER_PROVISIONED  = "%s %s: %s is over-provisioned (%.2f%% usage). Trim resources."
 )
 
 func WithNamespace(namespace string) Option {
@@ -36,50 +35,49 @@ func WithOutput(pathToFile string) Option {
 	}
 }
 
-func CheckUsage(usage float64, resourceType string, container string) string {
-	var message string
+func WithWarnings(includeWarnings bool) Option {
+	return func(config *scout.Config) {
+		config.Warnings = includeWarnings
+	}
+}
+
+func CheckUsage(usage float64, resourceType string, container string) scout.Advice {
+	var advice scout.Advice
 	switch {
-	case usage >= 100:
-		message = fmt.Sprintf(
-			OVER_100,
+	case usage >= 80:
+		advice.Kind = scout.DANGER
+		advice.Msg = fmt.Sprintf(
+			UNDER_PROVISIONED,
 			scout.FlashingLightEmoji,
 			container,
 			resourceType,
 			usage,
-			resourceType,
 		)
-	case usage >= 80 && usage < 100:
-		message = fmt.Sprintf(
-			OVER_80,
-			scout.WarningSign,
-			container,
-			resourceType,
-			usage,
-		)
-	case usage >= 40 && usage < 80:
-		message = fmt.Sprintf(
-			OVER_40,
+	case usage >= 20 && usage < 80:
+		advice.Kind = scout.HEALTHY
+		advice.Msg = fmt.Sprintf(
+			WELL_PROVISIONED,
 			scout.SuccessEmoji,
 			container,
 			resourceType,
 			usage,
-			resourceType,
 		)
 	default:
-		message = fmt.Sprintf(
-			UNDER_40,
+		advice.Kind = scout.WARNING
+		advice.Msg = fmt.Sprintf(
+			OVER_PROVISIONED,
 			scout.WarningSign,
 			container,
 			resourceType,
 			usage,
 		)
 	}
 
-	return message
+	return advice
 }
 
 // outputToFile writes resource allocation advice for a Kubernetes pod to a file.
-func OutputToFile(ctx context.Context, cfg *scout.Config, name string, advice []string) error {
+func OutputToFile(ctx context.Context, cfg *scout.Config, name string, advice []scout.Advice) error {
 	file, err := os.OpenFile(cfg.Output, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
 		return errors.Wrap(err, "failed to open file")
@@ -90,8 +88,8 @@ func OutputToFile(ctx context.Context, cfg *scout.Config, name string, advice []
 		return errors.Wrap(err, "failed to write service name to file")
 	}
 
-	for _, msg := range advice {
-		if _, err := fmt.Fprintf(file, "%s\n", msg); err != nil {
+	for _, adv := range advice {
+		if _, err := fmt.Fprintf(file, "%s\n", adv.Msg); err != nil {
 			return errors.Wrap(err, "failed to write container advice to file")
 		}
 	}

internal/scout/advise/advise_test.go

@@ -16,35 +16,47 @@ func TestCheckUsage(t *testing.T) {
 		usage        float64
 		resourceType string
 		container    string
-		want         string
+		want         scout.Advice
 	}{
 		{
 			name:         "should return correct message for usage over 100",
 			usage:        110,
 			resourceType: "cpu",
 			container:    "gitserver-0",
-			want:         "\t🚨 gitserver-0: Your cpu usage is over 100% (110.00%). Add more cpu.",
+			want: scout.Advice{
+				Kind: scout.DANGER,
+				Msg:  "🚨 gitserver-0: cpu is under-provisioned (110.00% usage). Add resources.",
+			},
 		},
 		{
 			name:         "should return correct message for usage over 80 and under 100",
 			usage:        87,
 			resourceType: "memory",
 			container:    "gitserver-0",
-			want:         "\t⚠️  gitserver-0: Your memory usage is over 80% (87.00%). Consider raising limits.",
+			want: scout.Advice{
+				Kind: scout.DANGER,
+				Msg:  "🚨 gitserver-0: memory is under-provisioned (87.00% usage). Add resources.",
+			},
 		},
 		{
 			name:         "should return correct message for usage over 40 and under 80",
 			usage:        63.4,
 			resourceType: "memory",
 			container:    "gitserver-0",
-			want:         "\t✅ gitserver-0: Your memory usage is under 80% (63.40%). Keep memory allocation the same.",
+			want: scout.Advice{
+				Kind: scout.HEALTHY,
+				Msg:  "✅ gitserver-0: memory is well-provisioned (63.40% usage). No action needed.",
+			},
 		},
 		{
 			name:         "should return correct message for usage under 40",
-			usage:        22.33,
+			usage:        12.33,
 			resourceType: "memory",
 			container:    "gitserver-0",
-			want:         "\t⚠️  gitserver-0: Your memory usage is under 40% (22.33%). Consider lowering limits.",
+			want: scout.Advice{
+				Kind: scout.WARNING,
+				Msg:  "⚠️  gitserver-0: memory is over-provisioned (12.33% usage). Trim resources.",
+			},
 		},
 	}
 
@@ -65,9 +77,15 @@ func TestOutputToFile(t *testing.T) {
 		Output: os.TempDir() + string(os.PathSeparator) + "test.txt",
 	}
 	name := "gitserver-0"
-	advice := []string{
-		"Add more CPU",
-		"Add more memory",
+	advice := []scout.Advice{
+		{
+			Kind: scout.WARNING,
+			Msg:  "Add more CPU",
+		},
+		{
+			Kind: scout.WARNING,
+			Msg:  "Add more memory",
+		},
 	}
 
 	err := OutputToFile(context.Background(), cfg, name, advice)
@@ -82,13 +100,14 @@ func TestOutputToFile(t *testing.T) {
 		want    string
 	}{
 		{1, "- gitserver-0"},
-		{2, "Add more CPU"},
-		{3, "Add more memory"},
+		{2, advice[0].Msg},
+		{3, advice[1].Msg},
 	}
 
 	for _, tc := range cases {
 		tc := tc
-		if lines[tc.lineNum-1] != tc.want {
+		got := lines[tc.lineNum-1]
+		if got != tc.want {
 			t.Errorf("Expected %q, got %q", tc.want, lines[tc.lineNum-1])
 		}
 	}

internal/scout/advise/k8s.go

@@ -3,6 +3,7 @@ package advise
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/sourcegraph/sourcegraph/lib/errors"
 	"github.com/sourcegraph/src-cli/internal/scout"
@@ -24,6 +25,7 @@ func K8s(
 		Namespace:     "default",
 		Pod:           "",
 		Output:        "",
+		Warnings:      false,
 		RestConfig:    restConfig,
 		K8sClient:     k8sClient,
 		MetricsClient: metricsClient,
@@ -51,6 +53,10 @@ func K8s(
 		return nil
 	}
 
+	if cfg.Output != "" {
+		fmt.Printf("writing to %s. This can take a few minutes...", cfg.Output)
+	}
+
 	for _, pod := range pods {
 		err = Advise(ctx, cfg, pod)
 		if err != nil {
@@ -67,29 +73,42 @@ func K8s(
 // of a resource is needed. Advice is generated and either printed to the console
 // or output to a file depending on the cfg.Output field.
 func Advise(ctx context.Context, cfg *scout.Config, pod v1.Pod) error {
-	var advice []string
+	var advice []scout.Advice
 	usageMetrics, err := getUsageMetrics(ctx, cfg, pod)
 	if err != nil {
 		return errors.Wrap(err, "could not get usage metrics")
 	}
-
 	for _, metrics := range usageMetrics {
 		cpuAdvice := CheckUsage(metrics.CpuUsage, "CPU", metrics.ContainerName)
-		advice = append(advice, cpuAdvice)
+		if cfg.Warnings {
+			advice = append(advice, cpuAdvice)
+		} else if !cfg.Warnings && cpuAdvice.Kind != scout.WARNING {
+			advice = append(advice, cpuAdvice)
+		}
 
 		memoryAdvice := CheckUsage(metrics.MemoryUsage, "memory", metrics.ContainerName)
-		advice = append(advice, memoryAdvice)
+		if cfg.Warnings {
+			advice = append(advice, memoryAdvice)
+		} else if !cfg.Warnings && memoryAdvice.Kind != scout.WARNING {
+			advice = append(advice, memoryAdvice)
+		}
 
 		if metrics.Storage != nil {
 			storageAdvice := CheckUsage(metrics.StorageUsage, "storage", metrics.ContainerName)
-			advice = append(advice, storageAdvice)
+			if cfg.Warnings {
+				advice = append(advice, storageAdvice)
+			} else if !cfg.Warnings && storageAdvice.Kind != scout.WARNING {
+				advice = append(advice, storageAdvice)
+			}
 		}
 
 		if cfg.Output != "" {
 			OutputToFile(ctx, cfg, pod.Name, advice)
 		} else {
-			for _, msg := range advice {
-				fmt.Println(msg)
+			fmt.Printf("%s %s: advising...\n", scout.EmojiFingerPointRight, pod.Name)
+			time.Sleep(time.Millisecond * 300)
+			for _, adv := range advice {
+				fmt.Printf("\t%s\n", adv.Msg)
 			}
 		}
 	}

internal/scout/constants.go

@@ -6,4 +6,7 @@ const (
 	FlashingLightEmoji            = "🚨"
 	SuccessEmoji                  = "✅"
 	WarningSign                   = "⚠️ " // why does this need an extra space to align?!?!
+	HEALTHY                       = "HEALTHY"
+	WARNING                       = "WARNING"
+	DANGER                        = "DANGER"
 )

internal/scout/types.go

@@ -11,6 +11,7 @@ type Config struct {
 	Namespace     string
 	Pod           string
 	Output        string
+	Warnings      bool
 	RestConfig    *rest.Config
 	K8sClient     *kubernetes.Clientset
 	MetricsClient *metricsv.Clientset
@@ -36,3 +37,8 @@ type UsageStats struct {
 	MemoryUsage   float64
 	StorageUsage  float64
 }
+
+type Advice struct {
+	Kind string
+	Msg  string
+}