Merge pull request #1 from AdminTurnedDevOps/feat/learn

Learn function removed

Author: AdminTurnedDevOps

README.md

@@ -15,6 +15,8 @@ Although numbers 1 and 2 are drastically important, number 3 is the make or brea
 
 All applications should perform as expected, and typically, bad performance stems from an networking issue (unless it's a specific app/code issue)
 
+**PLEASE NOTE**: This is for scanning real-time/current usage, not a forecasting tool that learns over time.
+
 ## How Does The ML Piece Work?
 
 SMAnalyzer uses a K-means clustering algorithm, which automatically sorts things into groups based on how similar they are to each other.

cmd/learn.go

@@ -6,63 +6,113 @@ import (
 	"log"
 	"time"
 
+	"smanalyzer/pkg/istio"
+	"smanalyzer/pkg/k8s"
+	"smanalyzer/pkg/output"
+
 	"github.com/spf13/cobra"
 )
 
 var monitorCmd = &cobra.Command{
 	Use:   "monitor",
-	Short: "Continuously monitor service mesh for anomalies",
-	Long: `Runs continuous monitoring of the service mesh, detecting anomalies in real-time
-and reporting them as they occur. Requires a baseline model to be learned first.`,
+	Short: "Continuously monitor service mesh metrics",
+	Long: `Runs continuous monitoring of the service mesh, displaying real-time metrics
+for all services including request counts, error rates, response times, and more.`,
 	Run: runMonitor,
 }
 
 var (
-	monitorInterval time.Duration
-	modelPath      string
-	outputFormat   string
+	monitorInterval  time.Duration
+	monitorNamespace string
+	outputFormat     string
 )
 
 func init() {
 	rootCmd.AddCommand(monitorCmd)
-	
+
 	monitorCmd.Flags().DurationVarP(&monitorInterval, "interval", "i", 30*time.Second, "Monitoring interval (e.g., 30s, 1m)")
-	monitorCmd.Flags().StringVarP(&modelPath, "model", "m", "", "Path to learned baseline model")
-	monitorCmd.Flags().StringVarP(&outputFormat, "format", "f", "text", "Output format (text, table, json)")
+	monitorCmd.Flags().StringVarP(&monitorNamespace, "namespace", "n", "default", "Kubernetes namespace to monitor")
+	monitorCmd.Flags().StringVarP(&outputFormat, "format", "f", "table", "Output format (text, table, json)")
 }
 
 func runMonitor(cmd *cobra.Command, args []string) {
 	ctx := context.Background()
-	
-	fmt.Printf("Starting continuous service mesh monitoring...\n")
+
+	fmt.Printf("Starting service mesh monitoring...\n")
+	fmt.Printf("Namespace: %s\n", monitorNamespace)
 	fmt.Printf("Interval: %v\n", monitorInterval)
 	fmt.Printf("Output format: %s\n", outputFormat)
-	
-	if modelPath != "" {
-		fmt.Printf("Using model: %s\n", modelPath)
-	}
-	
+	fmt.Println()
+
 	if err := performMonitoring(ctx); err != nil {
 		log.Fatalf("Monitoring failed: %v", err)
 	}
 }
 
 func performMonitoring(ctx context.Context) error {
-	fmt.Println("Loading baseline model...")
-	fmt.Println("Starting monitoring loop...")
-	
+	// Connect to Kubernetes cluster
+	k8sClient, err := k8s.NewClient()
+	if err != nil {
+		return fmt.Errorf("failed to create Kubernetes client: %w", err)
+	}
+
+	if err := k8sClient.CheckConnection(ctx); err != nil {
+		return fmt.Errorf("failed to connect to cluster: %w", err)
+	}
+
+	// Initialize service discovery
+	serviceDiscovery := istio.NewServiceDiscovery(k8sClient.Clientset)
+
+	// Initialize output formatter
+	formatter := output.NewFormatter(outputFormat)
+
+	fmt.Println("Connected to cluster, starting monitoring loop...")
+	fmt.Println()
+
 	ticker := time.NewTicker(monitorInterval)
 	defer ticker.Stop()
-	
+
 	for {
 		select {
 		case <-ctx.Done():
 			fmt.Println("Monitoring stopped")
 			return nil
 		case <-ticker.C:
-			fmt.Printf("[%s] Checking for anomalies...\n", time.Now().Format("15:04:05"))
-			
-			time.Sleep(1 * time.Second)
+			if err := collectAndDisplayMetrics(ctx, serviceDiscovery, formatter); err != nil {
+				fmt.Printf("Error collecting metrics: %v\n", err)
+			}
 		}
 	}
-}
+}
+
+func collectAndDisplayMetrics(ctx context.Context, sd *istio.ServiceDiscovery, formatter *output.Formatter) error {
+	// Discover services
+	services, err := sd.DiscoverServices(ctx, monitorNamespace)
+	if err != nil {
+		return fmt.Errorf("failed to discover services: %w", err)
+	}
+
+	fmt.Println("Please Note: This is a continuous monitoring loop. Press CTRL + C to leave")
+	fmt.Println()
+
+	for _, s := range services {
+		if len(s) == 0 {
+			fmt.Printf("[%s] No services found in namespace %s\n", time.Now().Format("15:04:05"), monitorNamespace)
+			break
+		}
+	}
+
+	// Collect metrics for each service
+	var allMetrics []*istio.ServiceMeshMetrics
+	for _, serviceName := range services {
+		metrics, err := sd.CollectMetrics(ctx, monitorNamespace, serviceName)
+		if err != nil {
+			fmt.Printf("Warning: failed to collect metrics for %s: %v\n", serviceName, err)
+			continue
+		}
+		allMetrics = append(allMetrics, metrics)
+	}
+
+	// Display metrics
+	return formatter.DisplayMetrics(allMetrics)
+}

cmd/monitor.go

@@ -15,10 +15,10 @@ var (
 
 var rootCmd = &cobra.Command{
 	Use:   "smanalyzer",
-	Short: "Service Mesh AI Anomaly Detection System",
-	Long: `SMAnalyzer is an ML-powered system that learns normal behavior patterns 
-in your Kubernetes Service Mesh and tells you the anomalies in network traffic, 
-circuit breaking, retries, and timeouts using time series analysis and clustering algorithms.`,
+	Short: "Service Mesh Monitoring and Analysis System",
+	Long: `SMAnalyzer monitors your Kubernetes Service Mesh in real-time, displaying 
+metrics for network traffic, circuit breaking, retries, and timeouts. It can also 
+scan for anomalies using ML-powered clustering algorithms.`,
 }
 
 func Execute() error {

cmd/root.go

@@ -86,7 +86,7 @@ func performScan(ctx context.Context) error {
 
 	clusteringEngine := ml.NewClusteringEngine(mlConfig)
 	detector := anomaly.NewDetector(detectionConfig, clusteringEngine)
-	formatter := output.NewFormatter(output.Format(config.Output.Format))
+	formatter := output.NewFormatter(config.Output.Format)
 
 	fmt.Println("Collecting service mesh metrics...")
 

cmd/scan.go

@@ -1,10 +1,12 @@
 package output
 
 import (
+	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
 	"smanalyzer/pkg/anomaly"
+	"smanalyzer/pkg/istio"
 )
 
 type Format string
@@ -19,8 +21,8 @@ type Formatter struct {
 	format Format
 }
 
-func NewFormatter(format Format) *Formatter {
-	return &Formatter{format: format}
+func NewFormatter(format string) *Formatter {
+	return &Formatter{format: Format(format)}
 }
 
 func (f *Formatter) FormatAnomalies(anomalies []anomaly.Anomaly) string {
@@ -105,4 +107,75 @@ func (f *Formatter) truncate(s string, maxLen int) string {
 		return s
 	}
 	return s[:maxLen-3] + "..."
+}
+
+func (f *Formatter) DisplayMetrics(metrics []*istio.ServiceMeshMetrics) error {
+	switch f.format {
+	case JSON:
+		return f.displayMetricsJSON(metrics)
+	case Table:
+		return f.displayMetricsTable(metrics)
+	default:
+		return f.displayMetricsText(metrics)
+	}
+}
+
+func (f *Formatter) displayMetricsText(metrics []*istio.ServiceMeshMetrics) error {
+	if len(metrics) == 0 {
+		fmt.Printf("[%s] No services found\n", time.Now().Format("15:04:05"))
+		return nil
+	}
+
+	fmt.Printf("[%s] Service Mesh Metrics:\n\n", time.Now().Format("15:04:05"))
+	
+	for _, m := range metrics {
+		fmt.Printf("Service: %s.%s\n", m.ServiceName, m.Namespace)
+		fmt.Printf("  Request Count: %d\n", m.RequestCount)
+		fmt.Printf("  Error Rate: %.2f%%\n", m.ErrorRate*100)
+		fmt.Printf("  Response Time: %v\n", m.ResponseTime)
+		fmt.Printf("  Circuit Breakers: %d\n", m.CircuitBreakers)
+		fmt.Printf("  Retry Count: %d\n", m.RetryCount)
+		fmt.Printf("  Timeout Count: %d\n", m.TimeoutCount)
+		fmt.Println()
+	}
+	
+	return nil
+}
+
+func (f *Formatter) displayMetricsTable(metrics []*istio.ServiceMeshMetrics) error {
+	if len(metrics) == 0 {
+		fmt.Printf("[%s] No services found\n", time.Now().Format("15:04:05"))
+		return nil
+	}
+
+	fmt.Printf("[%s] Service Mesh Metrics:\n\n", time.Now().Format("15:04:05"))
+	fmt.Printf("%-20s %-10s %-12s %-8s %-12s %-8s %-8s %-8s\n", 
+		"SERVICE", "NAMESPACE", "REQ_COUNT", "ERR_RATE", "RESP_TIME", "CIRCUIT", "RETRIES", "TIMEOUTS")
+	fmt.Printf("%-20s %-10s %-12s %-8s %-12s %-8s %-8s %-8s\n", 
+		"-------", "---------", "---------", "--------", "---------", "-------", "-------", "--------")
+	
+	for _, m := range metrics {
+		service := f.truncate(m.ServiceName, 19)
+		namespace := f.truncate(m.Namespace, 9)
+		
+		fmt.Printf("%-20s %-10s %-12d %-8.2f %-12v %-8d %-8d %-8d\n",
+			service, namespace, m.RequestCount, m.ErrorRate*100, 
+			m.ResponseTime, m.CircuitBreakers, m.RetryCount, m.TimeoutCount)
+	}
+	fmt.Println()
+	
+	return nil
+}
+
+func (f *Formatter) displayMetricsJSON(metrics []*istio.ServiceMeshMetrics) error {
+	data, err := json.MarshalIndent(metrics, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal metrics: %w", err)
+	}
+	
+	fmt.Printf("[%s] Service Mesh Metrics (JSON):\n", time.Now().Format("15:04:05"))
+	fmt.Println(string(data))
+	fmt.Println()
+	
+	return nil
 }