config: split ServerOptions into CharonOptions and ProxyOptions

cmd/charon/main.go

@@ -29,7 +29,7 @@ func main() {
 func run() error {
 	log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
-	opts := config.NewServerOptions()
+	opts := config.NewCharonOptions()
 	fs := flag.NewFlagSet("charon", flag.ExitOnError)
 	opts.AddFlags(fs)
 	_ = fs.Parse(os.Args[1:])
@@ -64,7 +64,7 @@ func run() error {
 	}
 	defer func() { _ = svc.Close() }()
 
-	tp, err := telemetry.Init(context.Background(), opts.Telemetry.CharonService, opts.Telemetry.ExporterURL)
+	tp, err := telemetry.Init(context.Background(), opts.Telemetry.ServiceName, opts.Telemetry.ExporterURL)
 	if err != nil {
 		log.Error("init tracer", "err", err)
 		return err
@@ -78,10 +78,10 @@ func run() error {
 	}
 
 	h := server.NewHandler(svc, log).WithMaxBodyBytes(int64(opts.MaxPayload))
-	srv := server.NewServerWithRegistry(opts.CharonListen, h, log, reg, tp)
+	srv := server.NewServerWithRegistry(opts.Listen, h, log, reg, tp)
 
 	go func() {
-		log.Info("starting charon", "addr", opts.CharonListen)
+		log.Info("starting charon", "addr", opts.Listen)
 		if err := srv.Start(); err != nil && err != http.ErrServerClosed {
 			log.Error("charon server error", "err", err)
 		}

cmd/charon/main_test.go

@@ -10,9 +10,8 @@ import (
 )
 
 func TestConfigDefaults(t *testing.T) {
-	opts := config.NewServerOptions()
-	require.False(t, opts.ProxyEnabled)
-	require.Equal(t, ":8080", opts.ProxyListen)
+	opts := config.NewCharonOptions()
+	require.Equal(t, ":8081", opts.Listen)
 	require.Equal(t, 30, opts.TTLDays)
 }
 

cmd/proxy/main.go

@@ -26,10 +26,8 @@ func main() {
 func run() error {
 	log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 
-	opts := config.NewServerOptions()
+	opts := config.NewProxyOptions()
 	fs := flag.NewFlagSet("proxy", flag.ExitOnError)
-	// TODO: split config.ServerOptions into CharonOptions + ProxyOptions so this
-	// binary doesn't silently accept (and ignore) Charon storage/TTL flags.
 	opts.AddFlags(fs)
 	_ = fs.Parse(os.Args[1:])
 	if err := opts.Complete(fs); err != nil {
@@ -41,7 +39,7 @@ func run() error {
 		return err
 	}
 
-	tp, err := telemetry.Init(context.Background(), opts.Telemetry.ProxyService, opts.Telemetry.ExporterURL)
+	tp, err := telemetry.Init(context.Background(), opts.Telemetry.ServiceName, opts.Telemetry.ExporterURL)
 	if err != nil {
 		log.Error("init tracer", "err", err)
 		return err
@@ -54,17 +52,17 @@ func run() error {
 		}()
 	}
 
-	timeout := time.Duration(opts.InferenceTimeoutSeconds) * time.Second
-	infClient := inference.New(opts.ProxyBackend, opts.ProxyAPIKey, timeout)
-	charonClient := charon.New(opts.ProxyCharonURL, timeout)
+	timeout := time.Duration(opts.TimeoutSeconds) * time.Second
+	infClient := inference.New(opts.Backend, opts.APIKey, timeout)
+	charonClient := charon.New(opts.CharonURL, timeout)
 
 	h := NewHandler(charonClient, infClient, log)
 	mux := http.NewServeMux()
 	RegisterHandlers(mux, h)
-	srv := server.NewServerFromMux(opts.ProxyListen, mux, log, tp)
+	srv := server.NewServerFromMux(opts.Listen, mux, log, tp)
 
 	go func() {
-		log.Info("starting proxy", "addr", opts.ProxyListen)
+		log.Info("starting proxy", "addr", opts.Listen)
 		if err := srv.Start(); err != nil && err != http.ErrServerClosed {
 			log.Error("proxy server error", "err", err)
 		}

internal/config/bytesize_test.go

@@ -79,7 +79,7 @@ func TestByteSizeUnmarshalErrors(t *testing.T) {
 }
 
 func TestByteSizeInConfig(t *testing.T) {
-	opts := config.NewServerOptions()
+	opts := config.NewCharonOptions()
 	fs := flag.NewFlagSet("test", flag.ContinueOnError)
 	opts.AddFlags(fs)
 	require.NoError(t, fs.Parse([]string{"--config", "testdata/bytesize.yaml"}))

internal/config/config_test.go

@@ -12,53 +12,64 @@ import (
 )
 
 func TestLoadDefaults(t *testing.T) {
-	opts := config.NewServerOptions()
+	charon := config.NewCharonOptions()
 	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	opts.AddFlags(fs)
+	charon.AddFlags(fs)
 	require.NoError(t, fs.Parse(nil))
-	require.NoError(t, opts.Complete(fs))
+	require.NoError(t, charon.Complete(fs))
 
-	// Proxy defaults
-	assert.False(t, opts.ProxyEnabled, "proxy must be off by default")
-	assert.Equal(t, ":8080", opts.ProxyListen)
-	assert.Equal(t, "http://127.0.0.1:8081", opts.ProxyCharonURL)
-	assert.Equal(t, "http://localhost:11434", opts.ProxyBackend)
-	assert.Equal(t, 120, opts.InferenceTimeoutSeconds)
-	// Charon defaults
-	assert.Equal(t, ":8081", opts.CharonListen)
-	assert.Equal(t, "./data", opts.DataDir)
-	assert.Equal(t, 30, opts.TTLDays)
-	assert.Equal(t, time.Hour, opts.WorkerTTLInterval)
+	assert.Equal(t, ":8081", charon.Listen)
+	assert.Equal(t, "./data", charon.DataDir)
+	assert.Equal(t, 30, charon.TTLDays)
+	assert.Equal(t, time.Hour, charon.WorkerTTLInterval)
+	assert.Equal(t, "charon", charon.Telemetry.ServiceName)
+
+	proxy := config.NewProxyOptions()
+	fs2 := flag.NewFlagSet("test", flag.ContinueOnError)
+	proxy.AddFlags(fs2)
+	require.NoError(t, fs2.Parse(nil))
+	require.NoError(t, proxy.Complete(fs2))
+
+	assert.Equal(t, ":8080", proxy.Listen)
+	assert.Equal(t, "http://localhost:11434", proxy.Backend)
+	assert.Equal(t, "http://127.0.0.1:8081", proxy.CharonURL)
+	assert.Equal(t, 120, proxy.TimeoutSeconds)
+	assert.Equal(t, "charon-proxy", proxy.Telemetry.ServiceName)
 }
 
 func TestCharonURLDerivedFromListen(t *testing.T) {
 	// When charon.listen is set in the file and proxy.charon_url is not,
-	// ProxyCharonURL is auto-derived from the file's charon.listen.
-	opts := config.NewServerOptions()
+	// CharonURL is auto-derived from the file's charon.listen.
+	proxy := config.NewProxyOptions()
 	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	opts.AddFlags(fs)
+	proxy.AddFlags(fs)
 	require.NoError(t, fs.Parse([]string{"--config", "testdata/config.yaml"}))
-	require.NoError(t, opts.Complete(fs))
-	assert.Equal(t, "http://127.0.0.1:9090", opts.ProxyCharonURL)
+	require.NoError(t, proxy.Complete(fs))
+	assert.Equal(t, "http://127.0.0.1:9090", proxy.CharonURL)
 }
 
 func TestLoadFromFile(t *testing.T) {
-	opts := config.NewServerOptions()
+	proxy := config.NewProxyOptions()
 	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	opts.AddFlags(fs)
+	proxy.AddFlags(fs)
 	require.NoError(t, fs.Parse([]string{"--config", "testdata/config.yaml"}))
-	require.NoError(t, opts.Complete(fs))
+	require.NoError(t, proxy.Complete(fs))
+	assert.Equal(t, ":0", proxy.Listen)
 
-	assert.Equal(t, ":0", opts.ProxyListen)
-	assert.Equal(t, 30, opts.TTLDays)
+	charon := config.NewCharonOptions()
+	fs2 := flag.NewFlagSet("test", flag.ContinueOnError)
+	charon.AddFlags(fs2)
+	require.NoError(t, fs2.Parse([]string{"--config", "testdata/config.yaml"}))
+	require.NoError(t, charon.Complete(fs2))
+	assert.Equal(t, 30, charon.TTLDays)
 }
 
 func TestLoadStrictRejectsUnknownFields(t *testing.T) {
-	opts := config.NewServerOptions()
+	charon := config.NewCharonOptions()
 	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	opts.AddFlags(fs)
+	charon.AddFlags(fs)
 	require.NoError(t, fs.Parse([]string{"--config", "testdata/invalid.yaml"}))
-	err := opts.Complete(fs)
+	err := charon.Complete(fs)
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "parse config")
 }