Add verbose configuration debugging to troubleshoot InstanceAware env mapping

.github/workflows/cli-release.yml

@@ -108,9 +108,41 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  test:
+    name: Run CLI Tests
+    needs: prepare
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+          check-latest: true
+          cache: true
+
+      - name: Get dependencies
+        run: |
+          cd cmd/modcli
+          go mod download
+          go mod verify
+
+      - name: Run CLI tests
+        run: |
+          cd cmd/modcli
+          go test ./... -v -race
+
+      - name: Run lint checks
+        run: |
+          go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+          cd cmd/modcli
+          golangci-lint run
+
   build:
     name: Build CLI
-    needs: prepare
+    needs: [prepare, test]
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -151,7 +183,7 @@ jobs:
   release:
     name: Create Release
     runs-on: ubuntu-latest
-    needs: [prepare, build]
+    needs: [prepare, test, build]
     steps:
       - name: Checkout code
         uses: actions/checkout@v4

.github/workflows/examples-ci.yml

@@ -26,6 +26,8 @@ jobs:
           - http-client
           - advanced-logging
           - multi-tenant-app
+          - instance-aware-db
+          - verbose-debug
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -98,7 +100,7 @@ jobs:
 
             kill $PID 2>/dev/null || true
 
-          elif [ "${{ matrix.example }}" = "reverse-proxy" ] || [ "${{ matrix.example }}" = "http-client" ] || [ "${{ matrix.example }}" = "advanced-logging" ] || [ "${{ matrix.example }}" = "multi-tenant-app" ]; then
+          elif [ "${{ matrix.example }}" = "reverse-proxy" ] || [ "${{ matrix.example }}" = "http-client" ] || [ "${{ matrix.example }}" = "advanced-logging" ] || [ "${{ matrix.example }}" = "multi-tenant-app" ] || [ "${{ matrix.example }}" = "verbose-debug" ] || [ "${{ matrix.example }}" = "instance-aware-db" ]; then
             # These apps just need to start without immediate errors
             timeout 5s ./example &
             PID=$!

application.go

@@ -151,6 +151,15 @@ type Application interface {
 	// Should be called before module registration to ensure
 	// all framework operations use the new logger.
 	SetLogger(logger Logger)
+
+	// SetVerboseConfig enables or disables verbose configuration debugging.
+	// When enabled, DEBUG level logging will be performed during configuration
+	// processing to show which config is being processed, which key is being
+	// evaluated, and which attribute or key is being searched for.
+	SetVerboseConfig(enabled bool)
+
+	// IsVerboseConfig returns whether verbose configuration debugging is enabled.
+	IsVerboseConfig() bool
 }
 
 // TenantApplication extends Application with multi-tenant functionality.
@@ -229,6 +238,7 @@ type StdApplication struct {
 	ctx            context.Context
 	cancel         context.CancelFunc
 	tenantService  TenantService // Added tenant service reference
+	verboseConfig  bool          // Flag for verbose configuration debugging
 }
 
 // NewStdApplication creates a new application instance with the provided configuration and logger.
@@ -665,7 +675,7 @@ func (app *StdApplication) resolveInterfaceBasedDependencies(
 func (app *StdApplication) findServiceByInterface(dep ServiceDependency) (service any, serviceName string) {
 	for serviceName, service := range app.svcRegistry {
 		serviceType := reflect.TypeOf(service)
-		if serviceType.Implements(dep.SatisfiesInterface) {
+		if app.typeImplementsInterface(serviceType, dep.SatisfiesInterface) {
 			return service, serviceName
 		}
 	}
@@ -815,6 +825,21 @@ func (app *StdApplication) SetLogger(logger Logger) {
 	app.logger = logger
 }
 
+// SetVerboseConfig enables or disables verbose configuration debugging
+func (app *StdApplication) SetVerboseConfig(enabled bool) {
+	app.verboseConfig = enabled
+	if enabled {
+		app.logger.Debug("Verbose configuration debugging enabled")
+	} else {
+		app.logger.Debug("Verbose configuration debugging disabled")
+	}
+}
+
+// IsVerboseConfig returns whether verbose configuration debugging is enabled
+func (app *StdApplication) IsVerboseConfig() bool {
+	return app.verboseConfig
+}
+
 // resolveDependencies returns modules in initialization order
 func (app *StdApplication) resolveDependencies() ([]string, error) {
 	// Create dependency graph

application_test.go

@@ -842,3 +842,86 @@ var (
 	ErrModuleStartFailed = fmt.Errorf("module start failed")
 	ErrModuleStopFailed  = fmt.Errorf("module stop failed")
 )
+
+func TestSetVerboseConfig(t *testing.T) {
+	tests := []struct {
+		name    string
+		enabled bool
+	}{
+		{
+			name:    "Enable verbose config",
+			enabled: true,
+		},
+		{
+			name:    "Disable verbose config",
+			enabled: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a mock logger to capture debug messages
+			mockLogger := &MockLogger{}
+
+			// Set up expectations for debug messages
+			if tt.enabled {
+				mockLogger.On("Debug", "Verbose configuration debugging enabled", []interface{}(nil)).Return()
+			} else {
+				mockLogger.On("Debug", "Verbose configuration debugging disabled", []interface{}(nil)).Return()
+			}
+
+			// Create application with mock logger
+			app := NewStdApplication(
+				NewStdConfigProvider(testCfg{Str: "test"}),
+				mockLogger,
+			)
+
+			// Test that verbose config is initially false
+			if app.IsVerboseConfig() != false {
+				t.Error("Expected verbose config to be initially false")
+			}
+
+			// Set verbose config
+			app.SetVerboseConfig(tt.enabled)
+
+			// Verify the setting was applied
+			if app.IsVerboseConfig() != tt.enabled {
+				t.Errorf("Expected verbose config to be %v, got %v", tt.enabled, app.IsVerboseConfig())
+			}
+
+			// Verify mock expectations were met
+			mockLogger.AssertExpectations(t)
+		})
+	}
+}
+
+func TestIsVerboseConfig(t *testing.T) {
+	mockLogger := &MockLogger{}
+
+	// Create application
+	app := NewStdApplication(
+		NewStdConfigProvider(testCfg{Str: "test"}),
+		mockLogger,
+	)
+
+	// Test initial state
+	if app.IsVerboseConfig() != false {
+		t.Error("Expected IsVerboseConfig to return false initially")
+	}
+
+	// Test after enabling
+	mockLogger.On("Debug", "Verbose configuration debugging enabled", []interface{}(nil)).Return()
+	app.SetVerboseConfig(true)
+	if app.IsVerboseConfig() != true {
+		t.Error("Expected IsVerboseConfig to return true after enabling")
+	}
+
+	// Test after disabling
+	mockLogger.On("Debug", "Verbose configuration debugging disabled", []interface{}(nil)).Return()
+	app.SetVerboseConfig(false)
+	if app.IsVerboseConfig() != false {
+		t.Error("Expected IsVerboseConfig to return false after disabling")
+	}
+
+	mockLogger.AssertExpectations(t)
+}