cli: add slog to commands

cli/generate.go

@@ -7,7 +7,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -42,12 +42,17 @@ func runGenerate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to parse flags: %w", err)
 	}
 
-	paths, err := findGenerateTargets(args)
+	logger, err := newCLILogger(cmd)
 	if err != nil {
 		return err
 	}
 
-	if err := generatePolicies(cmd.Context(), flags.policyPath, flags.settingsPath, paths); err != nil {
+	paths, err := findGenerateTargets(args, logger)
+	if err != nil {
+		return err
+	}
+
+	if err := generatePolicies(cmd.Context(), flags.policyPath, flags.settingsPath, paths, logger); err != nil {
 		return fmt.Errorf("failed to generate policies: %w", err)
 	}
 
@@ -80,7 +85,7 @@ func runGenerate(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
-func findGenerateTargets(args []string) ([]string, error) {
+func findGenerateTargets(args []string, logger *slog.Logger) ([]string, error) {
 	var paths []string
 	for _, path := range args {
 		err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
@@ -103,34 +108,34 @@ func findGenerateTargets(args []string) ([]string, error) {
 		}
 	}
 
-	paths = filterNonCoCoRuntime("kata-cc-isolation", paths)
+	paths = filterNonCoCoRuntime("kata-cc-isolation", paths, logger)
 
 	if len(paths) == 0 {
 		return nil, fmt.Errorf("no .yml/.yaml files found")
 	}
 	return paths, nil
 }
 
-func filterNonCoCoRuntime(runtimeClassName string, paths []string) []string {
+func filterNonCoCoRuntime(runtimeClassName string, paths []string, logger *slog.Logger) []string {
 	var filtered []string
 	for _, path := range paths {
 		data, err := os.ReadFile(path)
 		if err != nil {
-			log.Printf("failed to read %s: %v", path, err)
+			logger.Warn("Failed to read file", "path", path, "err", err)
 			continue
 		}
 		if !bytes.Contains(data, []byte(runtimeClassName)) {
-			log.Printf("%s is not a CoCo runtime, ignoring", path)
+			logger.Info("Ignoring non-CoCo runtime", "className", runtimeClassName, "path", path)
 			continue
 		}
 		filtered = append(filtered, path)
 	}
 	return filtered
 }
 
-func generatePolicies(ctx context.Context, regoPath, policyPath string, yamlPaths []string) error {
+func generatePolicies(ctx context.Context, regoPath, policyPath string, yamlPaths []string, logger *slog.Logger) error {
 	for _, yamlPath := range yamlPaths {
-		policyHash, err := generatePolicyForFile(ctx, regoPath, policyPath, yamlPath)
+		policyHash, err := generatePolicyForFile(ctx, regoPath, policyPath, yamlPath, logger)
 		if err != nil {
 			return fmt.Errorf("failed to generate policy for %s: %w", yamlPath, err)
 		}
@@ -142,7 +147,7 @@ func generatePolicies(ctx context.Context, regoPath, policyPath string, yamlPath
 	return nil
 }
 
-func generatePolicyForFile(ctx context.Context, regoPath, policyPath, yamlPath string) ([32]byte, error) {
+func generatePolicyForFile(ctx context.Context, regoPath, policyPath, yamlPath string, logger *slog.Logger) ([32]byte, error) {
 	args := []string{
 		"--raw-out",
 		"--use-cached-files",
@@ -163,7 +168,7 @@ func generatePolicyForFile(ctx context.Context, regoPath, policyPath, yamlPath s
 		return [32]byte{}, fmt.Errorf("genpolicy failed: %w", err)
 	}
 	if stdout.Len() == 0 {
-		log.Printf("policy output for %s is empty, ignoring the file", yamlPath)
+		logger.Info("Policy output is empty, ignoring the file", "yamlPath", yamlPath)
 		return [32]byte{}, nil
 	}
 	policyHash := sha256.Sum256(stdout.Bytes())

cli/log.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"log/slog"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+func newCLILogger(cmd *cobra.Command) (*slog.Logger, error) {
+	rawLogLevel, err := cmd.Flags().GetString("log-level")
+	if err != nil {
+		rawLogLevel = "info"
+	}
+	var level slog.Level
+	switch strings.ToLower(rawLogLevel) {
+	case "debug":
+		level = slog.LevelDebug
+	case "":
+		fallthrough
+	case "info":
+		level = slog.LevelInfo
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		numericLevel, err := strconv.Atoi(rawLogLevel)
+		if err != nil {
+			return nil, fmt.Errorf("invalid log level: %q", rawLogLevel)
+		}
+		level = slog.Level(numericLevel)
+	}
+	opts := &slog.HandlerOptions{
+		Level: level,
+	}
+	return slog.New(slog.NewTextHandler(cmd.ErrOrStderr(), opts)), nil
+}

cli/main.go

@@ -31,6 +31,9 @@ func newRootCmd() *cobra.Command {
 		Version:          version,
 	}
 	cmd.SetOut(os.Stdout)
+
+	cmd.PersistentFlags().String("log-level", "info", "set logging level (debug, info, warn, error, or a number)")
+
 	cmd.InitDefaultVersionFlag()
 	cmd.AddCommand(
 		newGenerateCmd(),

cli/set.go

@@ -4,7 +4,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"log"
 	"net"
 	"os"
 
@@ -41,6 +40,11 @@ func runSet(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to parse flags: %w", err)
 	}
 
+	logger, err := newCLILogger(cmd)
+	if err != nil {
+		return err
+	}
+
 	manifestStr, err := os.ReadFile(flags.manifestPath)
 	if err != nil {
 		return fmt.Errorf("failed to read manifest file: %w", err)
@@ -51,7 +55,7 @@ func runSet(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to unmarshal manifest: %w", err)
 	}
 
-	paths, err := findGenerateTargets(args)
+	paths, err := findGenerateTargets(args, logger)
 	if err != nil {
 		return fmt.Errorf("finding yaml files: %w", err)
 	}
@@ -110,7 +114,7 @@ func runSet(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to set manifest: %w", err)
 	}
 
-	log.Println("Manifest set successfully")
+	logger.Info("Manifest set successfully")
 
 	if err := os.WriteFile("coordinator-root.pem", resp.CACert, 0o644); err != nil {
 		return fmt.Errorf("failed to write root certificate: %w", err)