feat(internal/librarian): add flag to configure verbose logging (#2285)

Adds -v flag to the CLI that sets the logging level to debug for each
command

Fixes #2148

Author: zhumin8

internal/librarian/doc.go

@@ -124,6 +124,7 @@ Flags:
 	  	local file path like /path/to/repo. Both absolute and relative paths are
 	  	supported. If not specified, will try to detect if the current working directory
 	  	is configured as a language repository.
+	-v	enables verbose logging
 
 # release
 

internal/librarian/flags.go

@@ -112,3 +112,7 @@ func addFlagWorkRoot(fs *flag.FlagSet, cfg *config.Config) {
 		`Working directory root. When this is not specified, a working directory
 will be created in /tmp.`)
 }
+
+func addFlagVerbose(fs *flag.FlagSet, p *bool) {
+	fs.BoolVar(p, "v", false, "enables verbose logging")
+}

internal/librarian/librarian.go

@@ -17,6 +17,8 @@ package librarian
 import (
 	"context"
 	"fmt"
+	"log/slog"
+	"os"
 
 	"github.com/googleapis/librarian/internal/cli"
 )
@@ -27,6 +29,16 @@ func Run(ctx context.Context, arg ...string) error {
 	return cmd.Run(ctx, arg)
 }
 
+func setupLogger(verbose bool) {
+	level := slog.LevelInfo
+	if verbose {
+		level = slog.LevelDebug
+	}
+	opts := &slog.HandlerOptions{Level: level}
+	handler := slog.NewTextHandler(os.Stderr, opts)
+	slog.SetDefault(slog.New(handler))
+}
+
 func newLibrarianCommand() *cli.Command {
 	cmdVersion := &cli.Command{
 		Short:     "version prints the version information",
@@ -65,11 +77,14 @@ func newLibrarianCommand() *cli.Command {
 }
 
 func newCmdGenerate() *cli.Command {
+	var verbose bool
 	cmdGenerate := &cli.Command{
 		Short:     "generate onboards and generates client library code",
 		UsageLine: "librarian generate [flags]",
 		Long:      generateLongHelp,
 		Action: func(ctx context.Context, cmd *cli.Command) error {
+			setupLogger(verbose)
+			slog.Debug("generate command verbose logging")
 			if err := cmd.Config.SetDefaults(); err != nil {
 				return fmt.Errorf("failed to initialize config: %w", err)
 			}
@@ -94,15 +109,19 @@ func newCmdGenerate() *cli.Command {
 	addFlagBranch(cmdGenerate.Flags, cmdGenerate.Config)
 	addFlagWorkRoot(cmdGenerate.Flags, cmdGenerate.Config)
 	addFlagPush(cmdGenerate.Flags, cmdGenerate.Config)
+	addFlagVerbose(cmdGenerate.Flags, &verbose)
 	return cmdGenerate
 }
 
 func newCmdTagAndRelease() *cli.Command {
+	var verbose bool
 	cmdTagAndRelease := &cli.Command{
 		Short:     "tag-and-release tags and creates a GitHub release for a merged pull request.",
 		UsageLine: "librarian release tag-and-release [arguments]",
 		Long:      tagAndReleaseLongHelp,
 		Action: func(ctx context.Context, cmd *cli.Command) error {
+			setupLogger(verbose)
+			slog.Debug("tag-and-release command verbose logging")
 			if err := cmd.Config.SetDefaults(); err != nil {
 				return fmt.Errorf("failed to initialize config: %w", err)
 			}
@@ -120,15 +139,19 @@ func newCmdTagAndRelease() *cli.Command {
 	addFlagRepo(cmdTagAndRelease.Flags, cmdTagAndRelease.Config)
 	addFlagPR(cmdTagAndRelease.Flags, cmdTagAndRelease.Config)
 	addFlagGitHubAPIEndpoint(cmdTagAndRelease.Flags, cmdTagAndRelease.Config)
+	addFlagVerbose(cmdTagAndRelease.Flags, &verbose)
 	return cmdTagAndRelease
 }
 
 func newCmdInit() *cli.Command {
+	var verbose bool
 	cmdInit := &cli.Command{
 		Short:     "init initiates a release by creating a release pull request.",
 		UsageLine: "librarian release init [flags]",
 		Long:      releaseInitLongHelp,
 		Action: func(ctx context.Context, cmd *cli.Command) error {
+			setupLogger(verbose)
+			slog.Debug("init command verbose logging")
 			if err := cmd.Config.SetDefaults(); err != nil {
 				return fmt.Errorf("failed to initialize config: %w", err)
 			}
@@ -151,5 +174,6 @@ func newCmdInit() *cli.Command {
 	addFlagRepo(cmdInit.Flags, cmdInit.Config)
 	addFlagBranch(cmdInit.Flags, cmdInit.Config)
 	addFlagWorkRoot(cmdInit.Flags, cmdInit.Config)
+	addFlagVerbose(cmdInit.Flags, &verbose)
 	return cmdInit
 }

internal/librarian/librarian_test.go

@@ -15,13 +15,17 @@
 package librarian
 
 import (
+	"bytes"
 	"context"
 	"fmt"
+	"io"
 	"log"
+	"log/slog"
 	"math/rand"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/go-git/go-git/v5"
@@ -34,14 +38,87 @@ import (
 	"github.com/google/go-cmp/cmp"
 )
 
-// TODO(https://github.com/googleapis/librarian/issues/202): add better tests
-// for librarian.Run.
 func TestRun(t *testing.T) {
 	if err := Run(t.Context(), []string{"version"}...); err != nil {
 		log.Fatal(err)
 	}
 }
 
+func TestVerboseFlag(t *testing.T) {
+	for _, test := range []struct {
+		name              string
+		args              []string
+		expectDebugLog    bool
+		expectDebugSubstr string
+	}{
+		{
+			name:              "generate with -v flag",
+			args:              []string{"generate", "-v"},
+			expectDebugLog:    true,
+			expectDebugSubstr: "generate command verbose logging",
+		},
+		{
+			name:           "generate without -v flag",
+			args:           []string{"generate"},
+			expectDebugLog: false,
+		},
+		{
+			name:              "release init with -v flag",
+			args:              []string{"release", "init", "-v"},
+			expectDebugLog:    true,
+			expectDebugSubstr: "init command verbose logging",
+		},
+		{
+			name:           "release init without -v flag",
+			args:           []string{"release", "init"},
+			expectDebugLog: false,
+		},
+		{
+			name:              "release tag-and-release with -v flag",
+			args:              []string{"release", "tag-and-release", "-v"},
+			expectDebugLog:    true,
+			expectDebugSubstr: "tag-and-release command verbose logging",
+		},
+		{
+			name:           "release tag-and-release without -v flag",
+			args:           []string{"release", "tag-and-release"},
+			expectDebugLog: false,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			// Redirect stderr to capture logs.
+			oldStderr := os.Stderr
+			r, w, _ := os.Pipe()
+			os.Stderr = w
+			// Reset logger to default for test isolation.
+			slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, nil)))
+
+			_ = Run(context.Background(), test.args...)
+
+			// Restore stderr and read the output.
+			w.Close()
+			os.Stderr = oldStderr
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := buf.String()
+
+			hasDebugLog := strings.Contains(output, "level=DEBUG")
+			if test.expectDebugLog {
+				if !hasDebugLog {
+					t.Errorf("expected debug log to be present, but it wasn't. Output:\n%s", output)
+				}
+				if !strings.Contains(output, test.expectDebugSubstr) {
+					t.Errorf("expected debug log to contain %q, but it didn't. Output:\n%s", test.expectDebugSubstr, output)
+				}
+			} else {
+				if hasDebugLog {
+					t.Errorf("expected debug log to be absent, but it was present. Output:\n%s", output)
+				}
+			}
+		})
+	}
+}
+
 func TestGenerate_DefaultBehavior(t *testing.T) {
 	ctx := context.Background()