Style Atmos Logger with Theme

examples/quick-start-simple/test_logger.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"errors"
+	"time"
+
+	"github.com/cloudposse/atmos/pkg/logger"
+)
+
+var ErrTest = errors.New("this is an error")
+
+const (
+	KeyComponent = "component"
+	KeyStack     = "stack"
+	KeyError     = "err"
+	KeyDuration  = "duration"
+	KeyPath      = "path"
+	KeyDetails   = "details"
+)
+
+func main() {
+	// Test individual log functions
+	testIndividualLogFunctions()
+
+	// Test complete Logger struct
+	testLoggerStruct()
+
+	// Test direct charmbracelet logger
+	testCharmLogger()
+}
+
+func testIndividualLogFunctions() {
+	logger.Info("This is an info message")
+	logger.Debug("This is a debug message with context", KeyComponent, "station", KeyDuration, "500ms")
+	logger.Warn("This is a warning message", KeyStack, "prod-ue1")
+	logger.Error("Whoops! Something went wrong", KeyError, "kitchen on fire", KeyComponent, "weather")
+
+	time.Sleep(500 * time.Millisecond)
+}
+
+func testLoggerStruct() {
+	atmosLogger, err := logger.InitializeLogger(logger.LogLevelTrace, "")
+	if err != nil {
+		panic(err)
+	}
+
+	atmosLogger.Trace("This is a trace message")
+	atmosLogger.Debug("This is a debug message")
+	atmosLogger.Info("This is an info message")
+	atmosLogger.Warning("This is a warning message")
+	atmosLogger.Error(ErrTest)
+
+	time.Sleep(500 * time.Millisecond)
+}
+
+func testCharmLogger() {
+	charmLogger := logger.GetCharmLogger()
+
+	charmLogger.SetTimeFormat(time.Kitchen)
+
+	charmLogger.Info("Processing component", KeyComponent, "station", KeyStack, "dev-ue1")
+	charmLogger.Debug("Found configuration", KeyPath, "/stacks/deploy/us-east-1/dev/station.yaml")
+	charmLogger.Warn("Component configuration outdated", KeyComponent, "weather", "lastUpdated", "90 days ago")
+	charmLogger.Error("Failed to apply changes",
+		KeyError, "validation failed",
+		KeyComponent, "weather",
+		KeyDetails, "required variables missing",
+		KeyStack, "dev-ue1")
+}

internal/exec/describe_affected.go

@@ -48,7 +48,7 @@
 	if err != nil {
 		return DescribeAffectedCmdArgs{}, err
 	}
-	logger, err := l.NewLoggerFromCliConfig(atmosConfig)
+	logger, err := l.InitializeLoggerFromCliConfig(&atmosConfig)
 	if err != nil {
 		return DescribeAffectedCmdArgs{}, err
 	}

internal/exec/pro.go

@@ -39,7 +39,7 @@
 		return ProLockUnlockCmdArgs{}, err
 	}
 
-	logger, err := l.NewLoggerFromCliConfig(atmosConfig)
+	logger, err := l.InitializeLoggerFromCliConfig(&atmosConfig)
 	if err != nil {
 		return ProLockUnlockCmdArgs{}, err
 	}

pkg/config/const.go

@@ -86,4 +86,6 @@ const (
 	AtmosYamlFuncEnv             = "!env"
 
 	TerraformDefaultWorkspace = "default"
+
+	StandardFilePermissions = 0o644
 )

pkg/logger/charmbracelet.go

@@ -0,0 +1,132 @@
+package logger
+
+import (
+	"os"
+
+	"github.com/charmbracelet/lipgloss"
+	log "github.com/charmbracelet/log"
+	"github.com/cloudposse/atmos/pkg/ui/theme"
+)
+
+var helperLogger *log.Logger
+
+func init() {
+	helperLogger = GetCharmLogger()
+}
+
+// GetCharmLogger returns a pre-configured Charmbracelet logger with Atmos styling.
+func GetCharmLogger() *log.Logger {
+	styles := getAtmosLogStyles()
+	logger := log.New(os.Stderr)
+	logger.SetStyles(styles)
+	return logger
+}
+
+// GetCharmLoggerWithOutput returns a pre-configured Charmbracelet logger with custom output.
+func GetCharmLoggerWithOutput(output *os.File) *log.Logger {
+	styles := getAtmosLogStyles()
+	logger := log.New(output)
+	logger.SetStyles(styles)
+	return logger
+}
+
+// getAtmosLogStyles returns custom styles for the Charmbracelet logger using Atmos theme colors.
+func getAtmosLogStyles() *log.Styles {
+	styles := log.DefaultStyles()
+
+	const (
+		paddingVertical   = 0
+		paddingHorizontal = 1
+	)
+
+	configureLogLevelStyles(styles, paddingVertical, paddingHorizontal)
+	configureKeyStyles(styles)
+
+	return styles
+}
+
+// configureLogLevelStyles configures the styles for different log levels.
+func configureLogLevelStyles(styles *log.Styles, paddingVertical, paddingHorizontal int) {
+	const (
+		errorLevelLabel = "ERROR"
+		warnLevelLabel  = "WARN"
+		infoLevelLabel  = "INFO"
+		debugLevelLabel = "DEBUG"
+	)
+
+	// Error.
+	styles.Levels[log.ErrorLevel] = lipgloss.NewStyle().
+		SetString(errorLevelLabel).
+		Padding(paddingVertical, paddingHorizontal, paddingVertical, paddingHorizontal).
+		Background(lipgloss.Color(theme.ColorPink)).
+		Foreground(lipgloss.Color(theme.ColorWhite))
+
+	// Warning.
+	styles.Levels[log.WarnLevel] = lipgloss.NewStyle().
+		SetString(warnLevelLabel).
+		Padding(paddingVertical, paddingHorizontal, paddingVertical, paddingHorizontal).
+		Background(lipgloss.Color(theme.ColorPink)).
+		Foreground(lipgloss.Color(theme.ColorDarkGray))
+
+	// Info.
+	styles.Levels[log.InfoLevel] = lipgloss.NewStyle().
+		SetString(infoLevelLabel).
+		Padding(paddingVertical, paddingHorizontal, paddingVertical, paddingHorizontal).
+		Background(lipgloss.Color(theme.ColorCyan)).
+		Foreground(lipgloss.Color(theme.ColorDarkGray))
+
+	// Debug.
+	styles.Levels[log.DebugLevel] = lipgloss.NewStyle().
+		SetString(debugLevelLabel).
+		Padding(paddingVertical, paddingHorizontal, paddingVertical, paddingHorizontal).
+		Background(lipgloss.Color(theme.ColorBlue)).
+		Foreground(lipgloss.Color(theme.ColorWhite))
+}
+
+// configureKeyStyles configures the styles for different log keys.
+func configureKeyStyles(styles *log.Styles) {
+	const (
+		keyError     = "error"
+		keyComponent = "component"
+		keyStack     = "stack"
+		keyDuration  = "duration"
+	)
+
+	// Custom style for 'err' key
+	styles.Keys[keyError] = lipgloss.NewStyle().Foreground(lipgloss.Color(theme.ColorPink))
+	styles.Values[keyError] = lipgloss.NewStyle().Bold(true)
+
+	// Custom style for 'component' key
+	styles.Keys[keyComponent] = lipgloss.NewStyle().Foreground(lipgloss.Color(theme.ColorPink))
+
+	// Custom style for 'stack' key
+	styles.Keys[keyStack] = lipgloss.NewStyle().Foreground(lipgloss.Color(theme.ColorBlue))
+
+	// Custom style for 'duration' key
+	styles.Keys[keyDuration] = lipgloss.NewStyle().Foreground(lipgloss.Color(theme.ColorGreen))
+}
+
+// Error logs an error message with context.
+func Error(message string, keyvals ...interface{}) {
+	helperLogger.Error(message, keyvals...)
+}
+
+// Warn logs a warning message with context.
+func Warn(message string, keyvals ...interface{}) {
+	helperLogger.Warn(message, keyvals...)
+}
+
+// Info logs an informational message with context.
+func Info(message string, keyvals ...interface{}) {
+	helperLogger.Info(message, keyvals...)
+}
+
+// Debug logs a debug message with context.
+func Debug(message string, keyvals ...interface{}) {
+	helperLogger.Debug(message, keyvals...)
+}
+
+// Fatal logs an error message and exits with status code 1.
+func Fatal(message string, keyvals ...interface{}) {
+	helperLogger.Fatal(message, keyvals...)
+}

pkg/logger/charmbracelet_test.go

@@ -0,0 +1,92 @@
+package logger
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+	log "github.com/charmbracelet/log"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetCharmLogger(t *testing.T) {
+	logger := GetCharmLogger()
+	require.NotNil(t, logger, "Should return a non-nil logger")
+
+	// These should not panic.
+	assert.NotPanics(t, func() {
+		logger.SetLevel(log.InfoLevel)
+		logger.SetTimeFormat("")
+	})
+}
+
+func TestGetCharmLoggerWithOutput(t *testing.T) {
+	tempDir := os.TempDir()
+	logFile := filepath.Join(tempDir, "charm_test.log")
+	defer os.Remove(logFile)
+
+	f, err := os.Create(logFile)
+	require.NoError(t, err, "Should create log file without error")
+
+	logger := GetCharmLoggerWithOutput(f)
+	require.NotNil(t, logger, "Should return a non-nil logger")
+
+	logger.SetTimeFormat("")
+	logger.Info("File test message")
+
+	f.Close()
+
+	data, err := os.ReadFile(logFile)
+	require.NoError(t, err, "Should read log file without error")
+
+	content := string(data)
+	assert.Contains(t, content, "INFO", "Should have INFO level in file")
+	assert.Contains(t, content, "File test message", "Should contain the message")
+}
+
+// Test the actual styling implementation.
+func TestCharmLoggerStylingDetails(t *testing.T) {
+	styles := getAtmosLogStyles()
+
+	assert.NotEqual(t, lipgloss.Style{}, styles.Levels[log.ErrorLevel], "ERROR level should have styling")
+	assert.NotEqual(t, lipgloss.Style{}, styles.Levels[log.WarnLevel], "WARN level should have styling")
+	assert.NotEqual(t, lipgloss.Style{}, styles.Levels[log.InfoLevel], "INFO level should have styling")
+	assert.NotEqual(t, lipgloss.Style{}, styles.Levels[log.DebugLevel], "DEBUG level should have styling")
+
+	assert.Contains(t, styles.Levels[log.ErrorLevel].Render("ERROR"), "ERROR", "ERROR label should be styled")
+	assert.Contains(t, styles.Levels[log.WarnLevel].Render("WARN"), "WARN", "WARN label should be styled")
+	assert.Contains(t, styles.Levels[log.InfoLevel].Render("INFO"), "INFO", "INFO label should be styled")
+	assert.Contains(t, styles.Levels[log.DebugLevel].Render("DEBUG"), "DEBUG", "DEBUG label should be styled")
+
+	assert.NotNil(t, styles.Keys["err"], "err key should have styling")
+	assert.NotNil(t, styles.Values["err"], "err value should have styling")
+	assert.NotNil(t, styles.Keys["component"], "component key should have styling")
+	assert.NotNil(t, styles.Keys["stack"], "stack key should have styling")
+}
+
+func ExampleGetCharmLogger() {
+	logger := GetCharmLogger()
+
+	logger.SetTimeFormat("2006-01-02 15:04:05")
+	logger.SetLevel(log.InfoLevel)
+
+	logger.Info("User logged in", "user_id", "12345", "component", "auth")
+
+	logger.Error("Failed to process request",
+		"err", "connection timeout",
+		"component", "api",
+		"duration", "1.5s")
+
+	logger.Warn("Resource utilization high",
+		"component", "database",
+		"stack", "prod-ue1",
+		"usage", "95%")
+
+	logger.Debug("Processing request",
+		"request_id", "abc123",
+		"component", "api",
+		"endpoint", "/users",
+		"method", "GET")
+}