Skip to content

Modern Docker Management, Designed for Everyone

perf: materialize the effective config once per refresh (#3619)

Kyle Mendell5769e81e0c26
diff --git a/backend/internal/settings/service.go b/backend/internal/settings/service.go
index 27ccd6922..f3df589ae 100644
--- a/backend/internal/settings/service.go
+++ b/backend/internal/settings/service.go
@@ -41,13 +41,20 @@ const (
)
type SettingsService struct {
- db *database.DB
- config atomic.Pointer[models.Settings]
- envOverrides []settingsEnvOverride
- writes *actors.Executor
- effects *actors.Executor
- lifecycleCtx context.Context
- changes *actors.Signal[[]libarcane.SettingUpdate]
+ db *database.DB
+ config atomic.Pointer[models.Settings]
+ // effectiveConfig is the env-override-applied snapshot, rebuilt whenever
+ // config is stored. Overrides are resolved once at startup and never
+ // change, so materializing them here turns every read (GetSettings and
+ // the typed getters — ~100 call sites, some in per-project loops) into a
+ // pointer load instead of a full struct Clone plus a reflection pass.
+ // The snapshot is shared: readers must never mutate it.
+ effectiveConfig atomic.Pointer[models.Settings]
+ envOverrides []settingsEnvOverride
+ writes *actors.Executor
+ effects *actors.Executor
+ lifecycleCtx context.Context
+ changes *actors.Signal[[]libarcane.SettingUpdate]
}
type settingsUpdateResultInternal struct {
@@ -166,6 +173,10 @@ func (s *SettingsService) LoadDatabaseSettings(ctx context.Context) (err error)
s.config.Store(dst)
+ effective := dst.Clone()
+ s.applyEnvOverrides(ctx, effective)
+ s.effectiveConfig.Store(effective)
+
return nil
}
@@ -436,6 +447,9 @@ func (s *SettingsService) IsEnvOverrideActive(key string) bool {
return false
}
+// GetSettings returns the effective (env-override-applied) settings snapshot.
+// The snapshot is shared across callers and must be treated as read-only;
+// mutation flows go through UpdateSettings, which works on an explicit clone.
func (s *SettingsService) GetSettings(ctx context.Context) (*models.Settings, error) {
settingsCfg := s.getEffectiveSettingsConfigInternal(ctx)
return settingsCfg, nil
@@ -457,6 +471,12 @@ func (s *SettingsService) GetSettingsOrDefaults(ctx context.Context) *models.Set
}
func (s *SettingsService) getEffectiveSettingsConfigInternal(ctx context.Context) *models.Settings {
+ if effective := s.effectiveConfig.Load(); effective != nil {
+ return effective
+ }
+
+ // Only reachable before LoadDatabaseSettings has completed in the
+ // constructor; fall back to building the snapshot per call.
settingsCfg := s.GetSettingsConfig().Clone()
s.applyEnvOverrides(ctx, settingsCfg)
return settingsCfg
diff --git a/backend/internal/settings/service_test.go b/backend/internal/settings/service_test.go
index bbc3a79f4..f46f7fb8d 100644
--- a/backend/internal/settings/service_test.go
+++ b/backend/internal/settings/service_test.go
@@ -1204,3 +1204,39 @@ func TestSettingsService_NormalizeProjectsDirectoryPublishesChangeInternal(t *te
require.Equal(t, "projectsDirectory", updates[0].Key)
require.True(t, filepath.IsAbs(updates[0].Value))
}
+
+// TestSettingsServiceEffectiveSnapshotMaterializedInternal verifies the
+// env-override-applied snapshot is built once per refresh: reads share one
+// pointer (no per-call clone), env overrides win over database values, and
+// an update rebuilds the snapshot while keeping the override applied.
+func TestSettingsServiceEffectiveSnapshotMaterializedInternal(t *testing.T) {
+ ctx := context.Background()
+ t.Setenv("PROJECTS_DIRECTORY", "/env/projects")
+
+ db := setupSettingsTestDB(t)
+ require.NoError(t, db.Create(&models.SettingVariable{Key: "projectsDirectory", Value: "/db/projects"}).Error)
+ require.NoError(t, db.Create(&models.SettingVariable{Key: "baseServerUrl", Value: "http://before.example"}).Error)
+
+ svc, err := newSettingsServiceForTestInternal(t, ctx, db)
+ require.NoError(t, err)
+
+ // Env override beats the database value on the effective snapshot.
+ require.Equal(t, "/env/projects", svc.GetStringSetting(ctx, "projectsDirectory", ""))
+
+ // Reads share the materialized snapshot instead of cloning per call.
+ first, err := svc.GetSettings(ctx)
+ require.NoError(t, err)
+ again, err := svc.GetSettings(ctx)
+ require.NoError(t, err)
+ require.Same(t, first, again)
+
+ // A settings update rebuilds the snapshot: the new value is visible and
+ // the env override is still applied.
+ require.NoError(t, svc.UpdateSetting(ctx, "baseServerUrl", "http://after.example"))
+ require.Equal(t, "http://after.example", svc.GetStringSetting(ctx, "baseServerUrl", ""))
+ require.Equal(t, "/env/projects", svc.GetStringSetting(ctx, "projectsDirectory", ""))
+
+ refreshed, err := svc.GetSettings(ctx)
+ require.NoError(t, err)
+ require.NotSame(t, first, refreshed)
+}