Post launch Log level control for the Server

cmd/spire-server/cli/cli.go

@@ -11,6 +11,7 @@ import (
 	"github.com/spiffe/spire/cmd/spire-server/cli/federation"
 	"github.com/spiffe/spire/cmd/spire-server/cli/healthcheck"
 	"github.com/spiffe/spire/cmd/spire-server/cli/jwt"
+	"github.com/spiffe/spire/cmd/spire-server/cli/logger"
 	"github.com/spiffe/spire/cmd/spire-server/cli/run"
 	"github.com/spiffe/spire/cmd/spire-server/cli/token"
 	"github.com/spiffe/spire/cmd/spire-server/cli/validate"
@@ -96,6 +97,12 @@ func (cc *CLI) Run(ctx context.Context, args []string) int {
 		"federation update": func() (cli.Command, error) {
 			return federation.NewUpdateCommand(), nil
 		},
+		"logger get": func() (cli.Command, error) {
+			return logger.NewGetCommand(), nil
+		},
+		"logger set": func() (cli.Command, error) {
+			return logger.NewSetCommand(), nil
+		},
 		"run": func() (cli.Command, error) {
 			return run.NewRunCommand(ctx, cc.LogOptions, cc.AllowUnknownConfig), nil
 		},

cmd/spire-server/cli/logger/get.go

@@ -0,0 +1,59 @@
+package logger
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	"github.com/mitchellh/cli"
+	api "github.com/spiffe/spire-api-sdk/proto/spire/api/server/logger/v1"
+	"github.com/spiffe/spire/cmd/spire-server/util"
+	commoncli "github.com/spiffe/spire/pkg/common/cli"
+	"github.com/spiffe/spire/pkg/common/cliprinter"
+)
+
+type getCommand struct {
+	env     *commoncli.Env
+	printer cliprinter.Printer
+}
+
+// Returns a cli.command that gets the logger information using
+// the default cli environment.
+func NewGetCommand() cli.Command {
+	return NewGetCommandWithEnv(commoncli.DefaultEnv)
+}
+
+// Returns a cli.command that gets the root logger information.
+func NewGetCommandWithEnv(env *commoncli.Env) cli.Command {
+	return util.AdaptCommand(env, &getCommand{env: env})
+}
+
+// The name of the command.
+func (*getCommand) Name() string {
+	return "logger get"
+}
+
+// The help presented description of the command.
+func (*getCommand) Synopsis() string {
+	return "Gets the logger details"
+}
+
+// Adds additional flags specific to the command.
+func (c *getCommand) AppendFlags(fs *flag.FlagSet) {
+	cliprinter.AppendFlagWithCustomPretty(&c.printer, fs, c.env, c.prettyPrintLogger)
+}
+
+// The routine that executes the command
+func (c *getCommand) Run(ctx context.Context, _ *commoncli.Env, serverClient util.ServerClient) error {
+	logger, err := serverClient.NewLoggerClient().GetLogger(ctx, &api.GetLoggerRequest{})
+	if err != nil {
+		return fmt.Errorf("error fetching logger: %w", err)
+	}
+
+	return c.printer.PrintProto(logger)
+}
+
+// Formatting for the logger under pretty printing of output.
+func (c *getCommand) prettyPrintLogger(env *commoncli.Env, results ...any) error {
+	return PrettyPrintLogger(env, results...)
+}

cmd/spire-server/cli/logger/get_posix_test.go

@@ -0,0 +1,12 @@
+//go:build !windows
+
+package logger_test
+
+var (
+	getUsage = `Usage of logger get:
+  -output value
+    	Desired output format (pretty, json); default: pretty.
+  -socketPath string
+    	Path to the SPIRE Server API socket (default "/tmp/spire-server/private/api.sock")
+`
+)

cmd/spire-server/cli/logger/get_test.go

@@ -0,0 +1,178 @@
+package logger_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/spiffe/spire-api-sdk/proto/spire/api/types"
+	"github.com/spiffe/spire/cmd/spire-server/cli/logger"
+)
+
+func TestGetHelp(t *testing.T) {
+	test := setupCliTest(t, nil, logger.NewGetCommandWithEnv)
+	test.client.Help()
+	require.Equal(t, "", test.stdout.String())
+	require.Equal(t, getUsage, test.stderr.String())
+}
+
+func TestGetSynopsis(t *testing.T) {
+	cmd := logger.NewGetCommand()
+	require.Equal(t, "Gets the logger details", cmd.Synopsis())
+}
+
+func TestGet(t *testing.T) {
+	for _, tt := range []struct {
+		name string
+		// server state
+		server *mockLoggerServer
+		// input
+		args []string
+		// expected items
+		expectReturnCode int
+		expectStdout     string
+		expectStderr     string
+	}{
+		{
+			name: "configured to info, set to info, using pretty output",
+			args: []string{"-output", "pretty"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_INFO,
+					LaunchLevel:  types.LogLevel_INFO,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `Logger Level : info
+Launch Level : info
+
+`,
+		},
+		{
+			name: "configured to debug, set to warn, using pretty output",
+			args: []string{"-output", "pretty"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_WARN,
+					LaunchLevel:  types.LogLevel_DEBUG,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `Logger Level : warning
+Launch Level : debug
+
+`,
+		},
+		{
+			name: "configured to error, set to trace, using pretty output",
+			args: []string{"-output", "pretty"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_TRACE,
+					LaunchLevel:  types.LogLevel_ERROR,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `Logger Level : trace
+Launch Level : error
+
+`,
+		},
+		{
+			name: "configured to panic, set to fatal, using pretty output",
+			args: []string{"-output", "pretty"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_FATAL,
+					LaunchLevel:  types.LogLevel_PANIC,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `Logger Level : fatal
+Launch Level : panic
+
+`,
+		},
+		{
+			name: "configured to info, set to info, using json output",
+			args: []string{"-output", "json"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_INFO,
+					LaunchLevel:  types.LogLevel_INFO,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `{"current_level":"INFO","launch_level":"INFO"}
+`,
+		},
+		{
+			name: "configured to debug, set to warn, using json output",
+			args: []string{"-output", "json"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_WARN,
+					LaunchLevel:  types.LogLevel_DEBUG,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `{"current_level":"WARN","launch_level":"DEBUG"}
+`,
+		},
+		{
+			name: "configured to error, set to trace, using json output",
+			args: []string{"-output", "json"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_TRACE,
+					LaunchLevel:  types.LogLevel_ERROR,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `{"current_level":"TRACE","launch_level":"ERROR"}
+`,
+		},
+		{
+			name: "configured to panic, set to fatal, using json output",
+			args: []string{"-output", "json"},
+			server: &mockLoggerServer{
+				returnLogger: &types.Logger{
+					CurrentLevel: types.LogLevel_FATAL,
+					LaunchLevel:  types.LogLevel_PANIC,
+				},
+			},
+			expectReturnCode: 0,
+			expectStdout: `{"current_level":"FATAL","launch_level":"PANIC"}
+`,
+		},
+		{
+			name: "configured to info, set to info, server will error",
+			args: []string{"-output", "pretty"},
+			server: &mockLoggerServer{
+				returnErr: errors.New("server is unavailable"),
+			},
+			expectReturnCode: 1,
+			expectStderr: `Error: error fetching logger: rpc error: code = Unknown desc = server is unavailable
+`,
+		},
+		{
+			name: "bizzarro world, returns neither logger nor error",
+			args: []string{"-output", "pretty"},
+			server: &mockLoggerServer{
+				returnLogger: nil,
+			},
+			expectReturnCode: 1,
+			expectStderr: `Error: internal error: returned current log level is undefined; please report this as a bug
+`,
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			test := setupCliTest(t, tt.server, logger.NewGetCommandWithEnv)
+			returnCode := test.client.Run(append(test.args, tt.args...))
+			require.Equal(t, tt.expectStdout, test.stdout.String())
+			require.Equal(t, tt.expectStderr, test.stderr.String())
+			require.Equal(t, tt.expectReturnCode, returnCode)
+		})
+	}
+}

cmd/spire-server/cli/logger/get_windows_test.go

@@ -0,0 +1,12 @@
+//go:build windows
+
+package logger_test
+
+var (
+	getUsage = `Usage of logger get:
+  -namedPipeName string
+    	Pipe name of the SPIRE Server API named pipe (default "\\spire-server\\private\\api")
+  -output value
+    	Desired output format (pretty, json); default: pretty.
+`
+)

cmd/spire-server/cli/logger/mocks_test.go

@@ -0,0 +1,110 @@
+package logger_test
+
+import (
+	"io"
+	"testing"
+
+	"github.com/spiffe/spire/test/spiretest"
+
+	"bytes"
+	"context"
+
+	"github.com/mitchellh/cli"
+	loggerv1 "github.com/spiffe/spire-api-sdk/proto/spire/api/server/logger/v1"
+	"github.com/spiffe/spire-api-sdk/proto/spire/api/types"
+	"github.com/spiffe/spire/cmd/spire-server/cli/common"
+	commoncli "github.com/spiffe/spire/pkg/common/cli"
+	"google.golang.org/grpc"
+)
+
+// an input/output capture struct
+type loggerTest struct {
+	stdin  *bytes.Buffer
+	stdout *bytes.Buffer
+	stderr *bytes.Buffer
+	args   []string
+	server *mockLoggerServer
+	client cli.Command
+}
+
+// serialization of capture
+func (l *loggerTest) afterTest(t *testing.T) {
+	t.Logf("TEST:%s", t.Name())
+	t.Logf("STDOUT:\n%s", l.stdout.String())
+	t.Logf("STDIN:\n%s", l.stdin.String())
+	t.Logf("STDERR:\n%s", l.stderr.String())
+}
+
+// setup of input/output capture
+func setupCliTest(t *testing.T, server *mockLoggerServer, newClient func(*commoncli.Env) cli.Command) *loggerTest {
+	addr := spiretest.StartGRPCServer(t, func(s *grpc.Server) {
+		loggerv1.RegisterLoggerServer(s, server)
+	})
+
+	stdin := new(bytes.Buffer)
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+
+	client := newClient(&commoncli.Env{
+		Stdin:  stdin,
+		Stdout: stdout,
+		Stderr: stderr,
+	})
+
+	test := &loggerTest{
+		stdin:  stdin,
+		stdout: stdout,
+		stderr: stderr,
+		args:   []string{common.AddrArg, common.GetAddr(addr)},
+		server: server,
+		client: client,
+	}
+
+	t.Cleanup(func() {
+		test.afterTest(t)
+	})
+
+	return test
+}
+
+// a mock grpc logger server
+type mockLoggerServer struct {
+	loggerv1.UnimplementedLoggerServer
+
+	receivedSetValue *types.LogLevel
+	returnLogger     *types.Logger
+	returnErr        error
+}
+
+// mock implementation for GetLogger
+func (s *mockLoggerServer) GetLogger(_ context.Context, _ *loggerv1.GetLoggerRequest) (*types.Logger, error) {
+	return s.returnLogger, s.returnErr
+}
+
+func (s *mockLoggerServer) SetLogLevel(_ context.Context, req *loggerv1.SetLogLevelRequest) (*types.Logger, error) {
+	s.receivedSetValue = &req.NewLevel
+	return s.returnLogger, s.returnErr
+}
+
+func (s *mockLoggerServer) ResetLogLevel(_ context.Context, _ *loggerv1.ResetLogLevelRequest) (*types.Logger, error) {
+	s.receivedSetValue = nil
+	return s.returnLogger, s.returnErr
+}
+
+var _ io.Writer = &errorWriter{}
+
+type errorWriter struct {
+	ReturnError error
+	Buffer      bytes.Buffer
+}
+
+func (e *errorWriter) Write(p []byte) (n int, err error) {
+	if e.ReturnError != nil {
+		return 0, e.ReturnError
+	}
+	return e.Buffer.Write(p)
+}
+
+func (e *errorWriter) String() string {
+	return e.Buffer.String()
+}