fix: honor LOG_LEVEL env in daemon logger (#686)

Author: 41tair

cmd/server/main.go

@@ -26,7 +26,7 @@ func main() {
 	}
 	time.Local = loc
 
-	logCloser, err := log.Init(config.LogOutputFormat == "json", config.LogFile)
+	logCloser, err := log.Init(config.LogOutputFormat == "json", config.LogFile, config.LogLevel)
 	if err != nil {
 		log.Panic("failed to init logger", "error", err)
 	}

internal/types/app/config.go

@@ -12,6 +12,7 @@ import (
 	"github.com/go-playground/validator/v10"
 	gormConfig "github.com/langgenius/dify-plugin-daemon/internal/db/config"
 	"github.com/langgenius/dify-plugin-daemon/pkg/entities/plugin_entities"
+	pkglog "github.com/langgenius/dify-plugin-daemon/pkg/utils/log"
 )
 
 const (
@@ -248,6 +249,7 @@ type Config struct {
 
 	// log settings
 	HealthApiLogEnabled bool   `envconfig:"HEALTH_API_LOG_ENABLED" default:"true"`
+	LogLevel            string `envconfig:"LOG_LEVEL" default:"INFO"`
 	LogOutputFormat     string `envconfig:"LOG_OUTPUT_FORMAT" default:"text"`
 	LogFile             string `envconfig:"LOG_FILE" default:""`
 
@@ -309,6 +311,9 @@ func (c *Config) Validate() error {
 			return fmt.Errorf("invalid gorm log level: '%s'. Valid levels are: silent, error, warn, info", c.DBGormLogLevel)
 		}
 	}
+	if _, err := pkglog.ParseLevel(c.LogLevel); err != nil {
+		return err
+	}
 	return nil
 }
 

internal/types/app/config_test.go

@@ -10,6 +10,73 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func newValidConfigForValidation() *Config {
+	config := &Config{
+		ServerPort:        5002,
+		ServerKey:         "test-key",
+		DifyInnerApiURL:   "http://localhost",
+		DifyInnerApiKey:   "test-api-key",
+		Platform:          PLATFORM_LOCAL,
+		PluginWorkingPath: "plugin-working",
+		DBType:            DB_TYPE_POSTGRESQL,
+		DBUsername:        "postgres",
+		DBPassword:        "postgres",
+		DBHost:            "localhost",
+		DBPort:            5432,
+		DBDatabase:        "plugin",
+	}
+	config.SetDefault()
+	return config
+}
+
+func TestValidateLogLevel(t *testing.T) {
+	tests := []struct {
+		name        string
+		logLevel    string
+		expectedErr string
+	}{
+		{
+			name:     "empty uses default",
+			logLevel: "",
+		},
+		{
+			name:     "uppercase info",
+			logLevel: "INFO",
+		},
+		{
+			name:     "uppercase warn",
+			logLevel: "WARN",
+		},
+		{
+			name:        "invalid level",
+			logLevel:    "verbose",
+			expectedErr: `invalid LOG_LEVEL "verbose". Valid values are: DEBUG, INFO, WARN, ERROR`,
+		},
+		{
+			name:        "lowercase rejected",
+			logLevel:    "info",
+			expectedErr: `invalid LOG_LEVEL "info". Valid values are: DEBUG, INFO, WARN, ERROR`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			config := newValidConfigForValidation()
+			config.LogLevel = tt.logLevel
+
+			err := config.Validate()
+
+			if tt.expectedErr != "" {
+				require.Error(t, err)
+				assert.Equal(t, tt.expectedErr, err.Error())
+				return
+			}
+
+			require.NoError(t, err)
+		})
+	}
+}
+
 func TestRedisTLSConfig(t *testing.T) {
 	tests := []struct {
 		name           string

internal/types/app/default.go

@@ -33,6 +33,7 @@ func (config *Config) SetDefault() {
 	setDefaultString(&config.PluginStorageLocalRoot, "storage")
 	setDefaultString(&config.PluginInstalledPath, "plugin")
 	setDefaultString(&config.PluginMediaCachePath, "assets")
+	setDefaultString(&config.LogLevel, "INFO")
 	setDefaultString(&config.PersistenceStoragePath, "persistence")
 	setDefaultInt(&config.PluginLocalLaunchingConcurrent, 2)
 	setDefaultInt(&config.PersistenceStorageMaxSize, 100*1024*1024)

pkg/utils/log/log.go

@@ -15,7 +15,24 @@ import (
 
 const ServiceName = "dify-plugin-daemon"
 
-func Init(json bool, filename string) (io.Closer, error) {
+func ParseLevel(value string) (slog.Level, error) {
+	switch value {
+	case "":
+		return slog.LevelInfo, nil
+	case "DEBUG":
+		return slog.LevelDebug, nil
+	case "INFO":
+		return slog.LevelInfo, nil
+	case "WARN":
+		return slog.LevelWarn, nil
+	case "ERROR":
+		return slog.LevelError, nil
+	default:
+		return 0, fmt.Errorf("invalid LOG_LEVEL %q. Valid values are: DEBUG, INFO, WARN, ERROR", value)
+	}
+}
+
+func Init(json bool, filename string, level string) (io.Closer, error) {
 	var w io.Writer = os.Stdout
 	var closer io.Closer
 	if filename != "" {
@@ -30,8 +47,17 @@ func Init(json bool, filename string) (io.Closer, error) {
 		w = io.MultiWriter(os.Stdout, file)
 		closer = file
 	}
+
+	logLevel, err := ParseLevel(level)
+	if err != nil {
+		if closer != nil {
+			_ = closer.Close()
+		}
+		return nil, err
+	}
+
 	handler := NewHandler(Options{
-		Level:   slog.LevelInfo,
+		Level:   logLevel,
 		Service: ServiceName,
 		JSON:    json,
 		Out:     w,

pkg/utils/log/log_test.go

@@ -0,0 +1,64 @@
+package log
+
+import (
+	"log/slog"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseLevel(t *testing.T) {
+	tests := []struct {
+		name        string
+		value       string
+		expected    slog.Level
+		expectedErr string
+	}{
+		{
+			name:     "empty defaults to info",
+			value:    "",
+			expected: slog.LevelInfo,
+		},
+		{
+			name:     "uppercase info",
+			value:    "INFO",
+			expected: slog.LevelInfo,
+		},
+		{
+			name:     "uppercase debug",
+			value:    "DEBUG",
+			expected: slog.LevelDebug,
+		},
+		{
+			name:        "invalid level",
+			value:       "verbose",
+			expectedErr: `invalid LOG_LEVEL "verbose". Valid values are: DEBUG, INFO, WARN, ERROR`,
+		},
+		{
+			name:        "lowercase rejected",
+			value:       "info",
+			expectedErr: `invalid LOG_LEVEL "info". Valid values are: DEBUG, INFO, WARN, ERROR`,
+		},
+		{
+			name:        "warning alias rejected",
+			value:       "WARNING",
+			expectedErr: `invalid LOG_LEVEL "WARNING". Valid values are: DEBUG, INFO, WARN, ERROR`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			level, err := ParseLevel(tt.value)
+
+			if tt.expectedErr != "" {
+				require.Error(t, err)
+				assert.Equal(t, tt.expectedErr, err.Error())
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, level)
+		})
+	}
+}