🔀 Merge branch 'rel/0.3.1' into stable

🔖 0.3.0 release: refactor config with viper

AGENTS.md

@@ -22,7 +22,7 @@
 
 ## Config System
 - Viper instance is stored in context using a custom key type (`confKeyType`)
-- Use `config.New(path, overrides)` to create a new viper instance
+- Use `config.New(ctx, path)` to create a new viper instance
 - Use `config.RetrieveFromContext(ctx)` to get both viper and the unmarshaled Config struct
 - Formatters can use `v.Sub("formatters." + kind)` to get their own sub-config and unmarshal into their specific config struct
 - Test files must create viper instances and add them to context using `config.AddToContext`

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.3.1] - 2026-03-09
+
+- Add AddFormatter function to allow custom builds to register new formatters
+- Add option to print config from config command
+- Allow MYLOG_CONFIG_PATH to override the config path
+
 ## [0.3.0] - 2026-03-09
 
 - Refactor configuration to use viper with context propagation instead of global variables

cli/config.go

@@ -22,12 +22,13 @@ import (
 	fp "path/filepath"
 
 	"codeberg.org/danjones000/my-log/config"
+	"github.com/pelletier/go-toml/v2"
 	"github.com/spf13/cobra"
 )
 
 var ConfigCmd = &cobra.Command{
 	Use:          "config",
-	Short:        "Save default config to file",
+	Short:        "Save default config to file, or print the current config value",
 	SilenceUsage: true,
 	RunE: func(cmd *cobra.Command, args []string) (err error) {
 		print, _ := cmd.Flags().GetBool("print")
@@ -35,6 +36,24 @@ var ConfigCmd = &cobra.Command{
 			fmt.Fprintln(cmd.OutOrStdout(), config.DefaultPath())
 			return nil
 		}
+
+		if len(args) > 0 {
+			v, _ := config.RetrieveFromContext(cmd.Context())
+			val := v.Get(args[0])
+			var out []byte
+			if val == nil {
+				out = []byte("<nil>")
+			} else {
+				var err error
+				out, err = toml.Marshal(val)
+				if err != nil {
+					return err
+				}
+			}
+			fmt.Fprintln(cmd.OutOrStdout(), string(out))
+			return nil
+		}
+
 		force, _ := cmd.Flags().GetBool("force")
 		configPath := config.DefaultPath()
 		if !force {

cli/root.go

@@ -28,19 +28,12 @@ var RootCmd = &cobra.Command{
 	Use:   "my-log",
 	Short: "A brief description of your application",
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-		ctx, v, err := config.New(cmd.Context())
+
+		ctx, v, err := config.New(cmd.Context(), configPath)
 		if err != nil {
 			return err
 		}
 
-		if configPath != "" {
-			v.SetConfigFile(configPath)
-			err := v.ReadInConfig()
-			if err != nil {
-				return err
-			}
-		}
-
 		for k, val := range configValues {
 			v.Set(k, val)
 		}
@@ -62,6 +55,10 @@ var configPath string
 var configValues map[string]string
 
 func init() {
-	RootCmd.PersistentFlags().StringVarP(&configPath, "config", "c", config.DefaultPath(), "config file")
+	path := os.Getenv("MYLOG_CONFIG_PATH")
+	if path == "" {
+		path = config.DefaultPath()
+	}
+	RootCmd.PersistentFlags().StringVarP(&configPath, "config", "c", path, "config file")
 	RootCmd.PersistentFlags().StringToStringVarP(&configValues, "config-value", "v", nil, "Override config values. Use dot syntax to specify key. E.g. -v formatters.preferred=json")
 }

config/load.go

@@ -32,7 +32,7 @@ func AddToContext(ctx context.Context, v *viper.Viper) context.Context {
 	return context.WithValue(ctx, viperKey, v)
 }
 
-func New(ctx context.Context) (context.Context, *viper.Viper, error) {
+func New(ctx context.Context, path string) (context.Context, *viper.Viper, error) {
 	v := viper.New()
 	v.SetConfigType("toml")
 
@@ -40,12 +40,16 @@ func New(ctx context.Context) (context.Context, *viper.Viper, error) {
 		return ctx, nil, err
 	}
 
-	v.SetConfigFile(DefaultPath())
+	if path == "" {
+		path = DefaultPath()
+	}
+
+	v.SetConfigFile(path)
 	v.SetEnvPrefix("MYLOG")
 	v.AutomaticEnv()
 	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
 
-	if err := v.ReadInConfig(); err != nil {
+	if err := v.MergeInConfig(); err != nil {
 		return ctx, nil, err
 	}
 

config/load_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestNew(t *testing.T) {
-	_, v, err := New(t.Context())
+	_, v, err := New(t.Context(), "")
 	be.Err(t, err, nil)
 	be.True(t, v != nil)
 }
@@ -18,7 +18,7 @@ func TestNewWithEnvOverrides(t *testing.T) {
 	os.Setenv("MYLOG_INPUT_PATH", "/test/path")
 	defer os.Unsetenv("MYLOG_INPUT_PATH")
 
-	_, v, err := New(t.Context())
+	_, v, err := New(t.Context(), "")
 	be.Err(t, err, nil)
 	be.Equal(t, v.GetString("input.path"), "/test/path")
 }
@@ -32,12 +32,9 @@ path = "/file/path"
 ext = "log"`)
 	f.Close()
 
-	_, v, err := New(t.Context())
+	_, v, err := New(t.Context(), f.Name())
 	be.Err(t, err, nil)
 
-	v.SetConfigFile(f.Name())
-	v.SetConfigType("toml")
-	err = v.ReadInConfig()
 	be.Err(t, err, nil)
 	be.Equal(t, v.GetString("input.path"), "/file/path")
 	be.Equal(t, v.GetString("input.ext"), "log")

formatters/json.go

@@ -10,6 +10,8 @@ import (
 	"github.com/spf13/viper"
 )
 
+const FormatJSON string = "json"
+
 func newJson(ff *viper.Viper) (Formatter, error) {
 	js := new(Json)
 	err := ff.Unmarshal(js)
@@ -24,7 +26,7 @@ type Json struct {
 }
 
 func (js *Json) Name() string {
-	return "json"
+	return FormatJSON
 }
 
 func (js *Json) marshal(v any) (o []byte, err error) {

formatters/new.go

@@ -2,18 +2,22 @@ package formatters
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"sync"
 
 	"codeberg.org/danjones000/my-log/config"
 	"github.com/spf13/viper"
 )
 
-type formatMaker func(config *viper.Viper) (Formatter, error)
+var mut sync.RWMutex
 
-var formatterMap = map[string]formatMaker{
-	"plain": newPlain,
-	"json":  newJson,
-	"zero":  newNull,
+type FormatInit func(config *viper.Viper) (Formatter, error)
+
+var formatterMap = map[string]FormatInit{
+	FormatPlain: newPlain,
+	FormatJSON:  newJson,
+	FormatNull:  newNull,
 }
 
 func Preferred(ctx context.Context) (f Formatter, err error) {
@@ -25,6 +29,8 @@ func New(ctx context.Context, kind string) (f Formatter, err error) {
 	v, _ := config.RetrieveFromContext(ctx)
 	formatterConf := v.Sub("formatters." + kind)
 
+	mut.RLock()
+	defer mut.RUnlock()
 	if maker, ok := formatterMap[kind]; ok {
 		return maker(formatterConf)
 	}
@@ -34,8 +40,24 @@ func New(ctx context.Context, kind string) (f Formatter, err error) {
 
 func Kinds() []string {
 	r := []string{}
+
+	mut.RLock()
+	defer mut.RUnlock()
 	for kind, _ := range formatterMap {
 		r = append(r, kind)
 	}
 	return r
 }
+
+var ErrAlreadyAdded = errors.New("formatter already present")
+
+func AddFormatter(key string, f FormatInit) error {
+	mut.Lock()
+	defer mut.Unlock()
+	if _, present := formatterMap[key]; present {
+		return fmt.Errorf("%w: %s", ErrAlreadyAdded, key)
+	}
+
+	formatterMap[key] = f
+	return nil
+}

formatters/new_test.go

@@ -39,3 +39,17 @@ func TestPreferred(t *testing.T) {
 	be.Err(t, err, nil)
 	be.True(t, form != nil)
 }
+
+type dummyFormatter struct{ Null }
+
+func (dummyFormatter) Name() string { return "dummy" }
+
+func TestAddFormatter(t *testing.T) {
+	var df dummyFormatter
+	dummyInit := func(*viper.Viper) (Formatter, error) { return df, nil }
+	err := AddFormatter(df.Name(), dummyInit)
+	be.Err(t, err, nil)
+
+	err = AddFormatter(df.Name(), dummyInit)
+	be.Err(t, err, ErrAlreadyAdded)
+}

formatters/null.go

@@ -5,28 +5,19 @@ import (
 	"github.com/spf13/viper"
 )
 
-func newNull(ff *viper.Viper) (Formatter, error) {
-	return &Null{}, nil
+const FormatNull = "zero"
+
+func newNull(*viper.Viper) (Formatter, error) {
+	return Null{}, nil
 }
 
 type Null struct{}
 
-func (n *Null) Name() string {
-	return "zero"
+func (Null) Name() string {
+	return FormatNull
 }
 
-func (n *Null) Meta(m models.Meta) (o []byte, err error) {
-	return
-}
-
-func (n *Null) Entry(e models.Entry) (o []byte, err error) {
-	return
-}
-
-func (n *Null) Log(l models.Log) (o []byte, err error) {
-	return
-}
-
-func (n *Null) Logs(logs []models.Log) (out []byte, err error) {
-	return
-}
+func (Null) Meta(m models.Meta) (o []byte, err error)       { return }
+func (Null) Entry(e models.Entry) (o []byte, err error)     { return }
+func (Null) Log(l models.Log) (o []byte, err error)         { return }
+func (Null) Logs(logs []models.Log) (out []byte, err error) { return }

formatters/plain.go

@@ -8,16 +8,16 @@ import (
 	"github.com/spf13/viper"
 )
 
-func newPlain(ff *viper.Viper) (Formatter, error) {
+const FormatPlain string = "plain"
+
+func newPlain(*viper.Viper) (Formatter, error) {
 	return &PlainText{}, nil
 }
 
-type PlainText struct {
-	// config might go here some day
-}
+type PlainText struct{}
 
-func (pt *PlainText) Name() string {
-	return "plain"
+func (*PlainText) Name() string {
+	return FormatPlain
 }
 
 func (pt *PlainText) Logs(logs []models.Log) (out []byte, err error) {