fix: add mutex protection to FieldTracker and feeder fieldTracker access

Introduce FieldTrackerHolder with RWMutex in the feeders package for
thread-safe get/set of the tracker reference on shared feeder instances.
Add sync.Mutex to DefaultFieldTracker in both packages to protect
FieldPopulations slice and logger from concurrent access.

This fixes data races when multiple goroutines initialize separate
applications that share the global ConfigFeeders slice.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: intel352

config_field_tracking.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"sync"
 )
 
 // FieldTracker interface allows feeders to report which fields they populate
@@ -37,6 +38,7 @@ type FieldTrackingFeeder interface {
 
 // DefaultFieldTracker is a basic implementation of FieldTracker
 type DefaultFieldTracker struct {
+	mu               sync.Mutex
 	FieldPopulations []FieldPopulation
 	logger           Logger
 }
@@ -50,9 +52,12 @@ func NewDefaultFieldTracker() *DefaultFieldTracker {
 
 // RecordFieldPopulation records a field population event
 func (t *DefaultFieldTracker) RecordFieldPopulation(fp FieldPopulation) {
+	t.mu.Lock()
 	t.FieldPopulations = append(t.FieldPopulations, fp)
-	if t.logger != nil {
-		t.logger.Debug("Field populated",
+	logger := t.logger
+	t.mu.Unlock()
+	if logger != nil {
+		logger.Debug("Field populated",
 			"fieldPath", fp.FieldPath,
 			"fieldName", fp.FieldName,
 			"fieldType", fp.FieldType,
@@ -69,15 +74,20 @@ func (t *DefaultFieldTracker) RecordFieldPopulation(fp FieldPopulation) {
 
 // SetLogger sets the logger for the tracker
 func (t *DefaultFieldTracker) SetLogger(logger Logger) {
+	t.mu.Lock()
 	t.logger = logger
+	t.mu.Unlock()
 }
 
 // GetFieldPopulation returns the population info for a specific field path
 // It returns the first population found for the given field path
 func (t *DefaultFieldTracker) GetFieldPopulation(fieldPath string) *FieldPopulation {
+	t.mu.Lock()
+	defer t.mu.Unlock()
 	for _, fp := range t.FieldPopulations {
 		if fp.FieldPath == fieldPath {
-			return &fp
+			fpCopy := fp
+			return &fpCopy
 		}
 	}
 	return nil
@@ -86,6 +96,8 @@ func (t *DefaultFieldTracker) GetFieldPopulation(fieldPath string) *FieldPopulat
 // GetMostRelevantFieldPopulation returns the population info for a specific field path
 // It returns the last population that actually set a non-nil value
 func (t *DefaultFieldTracker) GetMostRelevantFieldPopulation(fieldPath string) *FieldPopulation {
+	t.mu.Lock()
+	defer t.mu.Unlock()
 	var lastPopulation *FieldPopulation
 	var lastValuedPopulation *FieldPopulation
 
@@ -110,6 +122,8 @@ func (t *DefaultFieldTracker) GetMostRelevantFieldPopulation(fieldPath string) *
 
 // GetPopulationsByFeeder returns all field populations by a specific feeder type
 func (t *DefaultFieldTracker) GetPopulationsByFeeder(feederType string) []FieldPopulation {
+	t.mu.Lock()
+	defer t.mu.Unlock()
 	var result []FieldPopulation
 	for _, fp := range t.FieldPopulations {
 		if fp.FeederType == feederType {
@@ -121,6 +135,8 @@ func (t *DefaultFieldTracker) GetPopulationsByFeeder(feederType string) []FieldP
 
 // GetPopulationsBySource returns all field populations by a specific source type
 func (t *DefaultFieldTracker) GetPopulationsBySource(sourceType string) []FieldPopulation {
+	t.mu.Lock()
+	defer t.mu.Unlock()
 	var result []FieldPopulation
 	for _, fp := range t.FieldPopulations {
 		if fp.SourceType == sourceType {

feeders/affixed_env.go

@@ -29,7 +29,7 @@ type AffixedEnvFeeder struct {
 	logger       interface {
 		Debug(msg string, args ...any)
 	}
-	fieldTracker FieldTracker
+	ft FieldTrackerHolder
 	priority     int
 }
 
@@ -40,7 +40,6 @@ func NewAffixedEnvFeeder(prefix, suffix string) *AffixedEnvFeeder {
 		Suffix:       suffix,
 		verboseDebug: false,
 		logger:       nil,
-		fieldTracker: nil,
 		priority:     0, // Default priority
 	}
 }
@@ -69,7 +68,7 @@ func (f *AffixedEnvFeeder) SetVerboseDebug(enabled bool, logger interface{ Debug
 
 // SetFieldTracker sets the field tracker for recording field populations
 func (f *AffixedEnvFeeder) SetFieldTracker(tracker FieldTracker) {
-	f.fieldTracker = tracker
+	f.ft.Set(tracker)
 }
 
 // Feed reads environment variables and populates the provided structure
@@ -209,21 +208,18 @@ func (f *AffixedEnvFeeder) setFieldFromEnv(field reflect.Value, fieldType *refle
 		}
 
 		// Record field population
-		if f.fieldTracker != nil {
-			convertedValue, _ := cast.FromType(envValue, field.Type())
-			fp := FieldPopulation{
-				FieldPath:  fieldPath,
-				FieldName:  fieldType.Name,
-				FieldType:  field.Type().String(),
-				FeederType: "AffixedEnvFeeder",
-				SourceType: "env_affixed",
-				SourceKey:  envName,
-				Value:      convertedValue,
-				SearchKeys: []string{envName},
-				FoundKey:   envName,
-			}
-			f.fieldTracker.RecordFieldPopulation(fp)
-		}
+		convertedValue, _ := cast.FromType(envValue, field.Type())
+		f.ft.Record(FieldPopulation{
+			FieldPath:  fieldPath,
+			FieldName:  fieldType.Name,
+			FieldType:  field.Type().String(),
+			FeederType: "AffixedEnvFeeder",
+			SourceType: "env_affixed",
+			SourceKey:  envName,
+			Value:      convertedValue,
+			SearchKeys: []string{envName},
+			FoundKey:   envName,
+		})
 
 		if f.verboseDebug && f.logger != nil {
 			f.logger.Debug("AffixedEnvFeeder: Successfully set field value", "envName", envName, "envValue", envValue)

feeders/base_config.go

@@ -18,7 +18,7 @@ type BaseConfigFeeder struct {
 	Environment  string // Environment name (e.g., "prod", "staging", "dev")
 	verboseDebug bool
 	logger       interface{ Debug(msg string, args ...any) }
-	fieldTracker FieldTracker
+	ft FieldTrackerHolder
 }
 
 // NewBaseConfigFeeder creates a new base configuration feeder
@@ -30,7 +30,6 @@ func NewBaseConfigFeeder(baseDir, environment string) *BaseConfigFeeder {
 		Environment:  environment,
 		verboseDebug: false,
 		logger:       nil,
-		fieldTracker: nil,
 	}
 }
 
@@ -45,7 +44,7 @@ func (b *BaseConfigFeeder) SetVerboseDebug(enabled bool, logger interface{ Debug
 
 // SetFieldTracker sets the field tracker for recording field populations
 func (b *BaseConfigFeeder) SetFieldTracker(tracker FieldTracker) {
-	b.fieldTracker = tracker
+	b.ft.Set(tracker)
 }
 
 // Feed loads and merges base configuration with environment-specific overrides

feeders/dot_env.go

@@ -16,7 +16,7 @@ type DotEnvFeeder struct {
 	logger       interface {
 		Debug(msg string, args ...any)
 	}
-	fieldTracker FieldTracker
+	ft FieldTrackerHolder
 	envVars      map[string]string // in-memory storage of parsed .env variables
 	priority     int
 }
@@ -27,7 +27,6 @@ func NewDotEnvFeeder(filePath string) *DotEnvFeeder {
 		Path:         filePath,
 		verboseDebug: false,
 		logger:       nil,
-		fieldTracker: nil,
 		envVars:      make(map[string]string),
 		priority:     0, // Default priority
 	}
@@ -57,7 +56,7 @@ func (f *DotEnvFeeder) SetVerboseDebug(enabled bool, logger interface{ Debug(msg
 
 // SetFieldTracker sets the field tracker for recording field populations
 func (f *DotEnvFeeder) SetFieldTracker(tracker FieldTracker) {
-	f.fieldTracker = tracker
+	f.ft.Set(tracker)
 }
 
 // Feed reads the .env file and populates the provided structure directly
@@ -255,20 +254,17 @@ func (f *DotEnvFeeder) setFieldValue(field reflect.Value, fieldType reflect.Stru
 	field.Set(reflect.ValueOf(convertedValue))
 
 	// Record field population
-	if f.fieldTracker != nil {
-		fp := FieldPopulation{
-			FieldPath:  fieldPath,
-			FieldName:  fieldType.Name,
-			FieldType:  field.Type().String(),
-			FeederType: "DotEnvFeeder",
-			SourceType: "dot_env_file",
-			SourceKey:  envKey,
-			Value:      convertedValue,
-			SearchKeys: []string{envKey},
-			FoundKey:   envKey,
-		}
-		f.fieldTracker.RecordFieldPopulation(fp)
-	}
+	f.ft.Record(FieldPopulation{
+		FieldPath:  fieldPath,
+		FieldName:  fieldType.Name,
+		FieldType:  field.Type().String(),
+		FeederType: "DotEnvFeeder",
+		SourceType: "dot_env_file",
+		SourceKey:  envKey,
+		Value:      convertedValue,
+		SearchKeys: []string{envKey},
+		FoundKey:   envKey,
+	})
 
 	return nil
 }

feeders/env.go

@@ -12,7 +12,7 @@ type EnvFeeder struct {
 	logger       interface {
 		Debug(msg string, args ...any)
 	}
-	fieldTracker FieldTracker
+	ft FieldTrackerHolder
 	priority     int
 }
 
@@ -49,7 +49,7 @@ func (f *EnvFeeder) SetVerboseDebug(enabled bool, logger interface{ Debug(msg st
 
 // SetFieldTracker sets the field tracker for this feeder
 func (f *EnvFeeder) SetFieldTracker(tracker FieldTracker) {
-	f.fieldTracker = tracker
+	f.ft.Set(tracker)
 	if f.verboseDebug && f.logger != nil {
 		f.logger.Debug("EnvFeeder: Field tracker set", "hasTracker", tracker != nil)
 	}
@@ -230,8 +230,7 @@ func (f *EnvFeeder) setFieldFromEnvWithModule(field reflect.Value, envTag, prefi
 		}
 
 		// Record field population if tracker is available
-		if f.fieldTracker != nil {
-			fp := FieldPopulation{
+		f.ft.Record(FieldPopulation{
 				FieldPath:   fieldPath,
 				FieldName:   fieldName,
 				FieldType:   field.Type().String(),
@@ -242,17 +241,14 @@ func (f *EnvFeeder) setFieldFromEnvWithModule(field reflect.Value, envTag, prefi
 				InstanceKey: "",
 				SearchKeys:  searchKeys,
 				FoundKey:    foundKey,
-			}
-			f.fieldTracker.RecordFieldPopulation(fp)
-		}
+			})
 
 		if f.verboseDebug && f.logger != nil {
 			f.logger.Debug("EnvFeeder: Successfully set field value", "fieldName", fieldName, "foundKey", foundKey, "envValue", envValue, "fieldPath", fieldPath)
 		}
 	} else {
 		// Record that we searched but didn't find
-		if f.fieldTracker != nil {
-			fp := FieldPopulation{
+		f.ft.Record(FieldPopulation{
 				FieldPath:   fieldPath,
 				FieldName:   fieldName,
 				FieldType:   field.Type().String(),
@@ -263,9 +259,7 @@ func (f *EnvFeeder) setFieldFromEnvWithModule(field reflect.Value, envTag, prefi
 				InstanceKey: "",
 				SearchKeys:  searchKeys,
 				FoundKey:    "",
-			}
-			f.fieldTracker.RecordFieldPopulation(fp)
-		}
+			})
 
 		if f.verboseDebug && f.logger != nil {
 			f.logger.Debug("EnvFeeder: Environment variable not found or empty", "fieldName", fieldName, "searchKeys", searchKeys, "fieldPath", fieldPath)
@@ -351,8 +345,7 @@ func (f *EnvFeeder) setPointerFieldFromEnvWithModule(field reflect.Value, envTag
 		field.Set(newValue)
 
 		// Record field population if tracker is available
-		if f.fieldTracker != nil {
-			fp := FieldPopulation{
+		f.ft.Record(FieldPopulation{
 				FieldPath:   fieldPath,
 				FieldName:   fieldName,
 				FieldType:   field.Type().String(),
@@ -363,17 +356,14 @@ func (f *EnvFeeder) setPointerFieldFromEnvWithModule(field reflect.Value, envTag
 				InstanceKey: "",
 				SearchKeys:  searchKeys,
 				FoundKey:    foundKey,
-			}
-			f.fieldTracker.RecordFieldPopulation(fp)
-		}
+			})
 
 		if f.verboseDebug && f.logger != nil {
 			f.logger.Debug("EnvFeeder: Successfully set pointer field", "fieldName", fieldName, "foundKey", foundKey, "fieldPath", fieldPath)
 		}
 	} else {
 		// Record that we searched but didn't find
-		if f.fieldTracker != nil {
-			fp := FieldPopulation{
+		f.ft.Record(FieldPopulation{
 				FieldPath:   fieldPath,
 				FieldName:   fieldName,
 				FieldType:   field.Type().String(),
@@ -384,9 +374,7 @@ func (f *EnvFeeder) setPointerFieldFromEnvWithModule(field reflect.Value, envTag
 				InstanceKey: "",
 				SearchKeys:  searchKeys,
 				FoundKey:    "",
-			}
-			f.fieldTracker.RecordFieldPopulation(fp)
-		}
+			})
 
 		if f.verboseDebug && f.logger != nil {
 			f.logger.Debug("EnvFeeder: Environment variable not found or empty for pointer field", "fieldName", fieldName, "searchKeys", searchKeys, "fieldPath", fieldPath)

feeders/field_tracking.go

@@ -1,5 +1,7 @@
 package feeders
 
+import "sync"
+
 // FieldPopulation represents a single field population event
 type FieldPopulation struct {
 	FieldPath   string      // Full path to the field (e.g., "Connections.primary.DSN")
@@ -22,6 +24,7 @@ type FieldTracker interface {
 
 // DefaultFieldTracker is a basic implementation of FieldTracker
 type DefaultFieldTracker struct {
+	mu          sync.Mutex
 	populations []FieldPopulation
 }
 
@@ -34,10 +37,48 @@ func NewDefaultFieldTracker() *DefaultFieldTracker {
 
 // RecordFieldPopulation records that a field was populated by a feeder
 func (t *DefaultFieldTracker) RecordFieldPopulation(fp FieldPopulation) {
+	t.mu.Lock()
 	t.populations = append(t.populations, fp)
+	t.mu.Unlock()
 }
 
 // GetFieldPopulations returns all recorded field populations
 func (t *DefaultFieldTracker) GetFieldPopulations() []FieldPopulation {
-	return t.populations
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	result := make([]FieldPopulation, len(t.populations))
+	copy(result, t.populations)
+	return result
+}
+
+// FieldTrackerHolder provides thread-safe access to a FieldTracker.
+// Feeders embed this instead of storing a raw FieldTracker field.
+type FieldTrackerHolder struct {
+	mu      sync.RWMutex
+	tracker FieldTracker
+}
+
+// Set stores the tracker (called by SetFieldTracker).
+func (h *FieldTrackerHolder) Set(tracker FieldTracker) {
+	h.mu.Lock()
+	h.tracker = tracker
+	h.mu.Unlock()
+}
+
+// Record is a convenience that nil-checks the tracker and calls RecordFieldPopulation.
+func (h *FieldTrackerHolder) Record(fp FieldPopulation) {
+	h.mu.RLock()
+	t := h.tracker
+	h.mu.RUnlock()
+	if t != nil {
+		t.RecordFieldPopulation(fp)
+	}
+}
+
+// Has returns true when a tracker has been set (non-nil).
+func (h *FieldTrackerHolder) Has() bool {
+	h.mu.RLock()
+	ok := h.tracker != nil
+	h.mu.RUnlock()
+	return ok
 }