Add error and event for mismatching input property

CHANGELOG.md

@@ -60,7 +60,7 @@ To learn more about active deprecations, we recommend checking [GitHub Discussio
 
 ### New
 
-- TODO ([#XXX](https://github.com/kedacore/keda/issues/XXX))
+- **General**: Add error and event for mismatching input property ([#6721](https://github.com/kedacore/keda/issues/6721))
 
 #### Experimental
 

pkg/scalers/scalersconfig/typed_config.go

@@ -29,7 +29,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
 
 	"github.com/kedacore/keda/v2/pkg/eventreason"
 )
@@ -158,21 +160,30 @@ func (sc *ScalerConfig) TypedConfig(typedConfig any) (err error) {
 			err = fmt.Errorf("failed to parse typed config %T resulted in panic\n%v", r, string(debug.Stack()))
 		}
 	}()
-	err = sc.parseTypedConfig(typedConfig, false)
+
+	logger := logf.Log.WithName("typed_config").WithValues("type", sc.ScalableObjectType, "namespace", sc.ScalableObjectNamespace, "name", sc.ScalableObjectName)
+
+	parsedParamNames, err := sc.parseTypedConfig(typedConfig, false)
+
+	if err == nil {
+		sc.checkUnexpectedParameterExist(parsedParamNames, logger)
+	}
+
 	return
 }
 
 // parseTypedConfig is a function that is used to unmarshal the TriggerMetadata, ResolvedEnv and AuthParams
 // this can be called recursively to parse nested structures
-func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) error {
+func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) ([]string, error) {
 	t := reflect.TypeOf(typedConfig)
 	if t.Kind() != reflect.Pointer {
-		return fmt.Errorf("typedConfig must be a pointer")
+		return nil, fmt.Errorf("typedConfig must be a pointer")
 	}
 	t = t.Elem()
 	v := reflect.ValueOf(typedConfig).Elem()
 
 	errs := []error{}
+	parsedParamNames := []string{}
 	for i := 0; i < t.NumField(); i++ {
 		fieldType := t.Field(i)
 		fieldValue := v.Field(i)
@@ -186,23 +197,26 @@ func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) e
 			continue
 		}
 		tagParams.Optional = tagParams.Optional || parentOptional
-		if err := sc.setValue(fieldValue, tagParams); err != nil {
+		parsed, err := sc.setValue(fieldValue, tagParams)
+		if err != nil {
 			errs = append(errs, err)
+		} else {
+			parsedParamNames = append(parsedParamNames, parsed...)
 		}
 	}
 	if validator, ok := typedConfig.(CustomValidator); ok {
 		if err := validator.Validate(); err != nil {
 			errs = append(errs, err)
 		}
 	}
-	return errors.Join(errs...)
+	return parsedParamNames, errors.Join(errs...)
 }
 
-// setValue is a function that sets the value of the field based on the provided params
-func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
+// setValue is a function that sets the value of the field based on the provided params, will return error and param names that set value
+func (sc *ScalerConfig) setValue(field reflect.Value, params Params) ([]string, error) {
 	valFromConfig, exists := sc.configParamValue(params)
 	if exists && params.IsDeprecated() {
-		return fmt.Errorf("parameter %q is deprecated%v", params.Name(), params.DeprecatedMessage())
+		return nil, fmt.Errorf("parameter %q is deprecated%v", params.Name(), params.DeprecatedMessage())
 	}
 	if exists && params.DeprecatedAnnounce != "" {
 		if sc.Recorder != nil {
@@ -216,14 +230,14 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 		valFromConfig = params.Default
 	}
 	if !exists && (params.Optional || params.IsDeprecated()) {
-		return nil
+		return nil, nil
 	}
 	if !exists && !(params.Optional || params.IsDeprecated()) {
 		if len(params.Order) == 0 {
 			apo := slices.Sorted(maps.Keys(allowedParsingOrderMap))
-			return fmt.Errorf("missing required parameter %q, no 'order' tag, provide any from %v", params.Name(), apo)
+			return nil, fmt.Errorf("missing required parameter %q, no 'order' tag, provide any from %v", params.Name(), apo)
 		}
-		return fmt.Errorf("missing required parameter %q in %v", params.Name(), params.Order)
+		return nil, fmt.Errorf("missing required parameter %q in %v", params.Name(), params.Order)
 	}
 	if params.Enum != nil {
 		enumMap := make(map[string]bool)
@@ -239,7 +253,7 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 			}
 		}
 		if len(missingMap) > 0 {
-			return fmt.Errorf("parameter %q value %q must be one of %v", params.Name(), valFromConfig, params.Enum)
+			return nil, fmt.Errorf("parameter %q value %q must be one of %v", params.Name(), valFromConfig, params.Enum)
 		}
 	}
 	if params.ExclusiveSet != nil {
@@ -256,7 +270,7 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 			}
 		}
 		if exclusiveCount > 1 {
-			return fmt.Errorf("parameter %q value %q must contain only one of %v", params.Name(), valFromConfig, params.ExclusiveSet)
+			return nil, fmt.Errorf("parameter %q value %q must contain only one of %v", params.Name(), valFromConfig, params.ExclusiveSet)
 		}
 	}
 	if params.IsNested() {
@@ -265,14 +279,14 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 			field = field.Elem()
 		}
 		if field.Kind() != reflect.Struct {
-			return fmt.Errorf("nested parameter %q must be a struct, has kind %q", params.FieldName, field.Kind())
+			return nil, fmt.Errorf("nested parameter %q must be a struct, has kind %q", params.FieldName, field.Kind())
 		}
 		return sc.parseTypedConfig(field.Addr().Interface(), params.Optional)
 	}
 	if err := setConfigValueHelper(params, valFromConfig, field); err != nil {
-		return fmt.Errorf("unable to set param %q value %q: %w", params.Name(), valFromConfig, err)
+		return nil, fmt.Errorf("unable to set param %q value %q: %w", params.Name(), valFromConfig, err)
 	}
-	return nil
+	return []string{params.Name()}, nil
 }
 
 // setConfigValueURLParams is a function that sets the value of the url.Values field
@@ -478,6 +492,25 @@ func (sc *ScalerConfig) configParamValue(params Params) (string, bool) {
 	return "", params.IsNested()
 }
 
+// checkUnexpectedParameterExist is a function that checks if there are any unexpected parameters in the TriggerMetadata
+func (sc *ScalerConfig) checkUnexpectedParameterExist(parsedParamNames []string, logger logr.Logger) {
+	for k := range sc.TriggerMetadata {
+		suffix := "FromEnv"
+		if !strings.HasSuffix(k, "FromEnv") {
+			suffix = ""
+		}
+		key := strings.TrimSuffix(k, suffix)
+		if !slices.Contains(parsedParamNames, key) {
+			if sc.Recorder != nil {
+				message := fmt.Sprintf("Unmatched input property %s in scaler %s", key+suffix, sc.ScalableObjectType)
+				// Just logging as it's optional property checking and should not block the scaling
+				logger.Error(nil, message)
+				sc.Recorder.Event(sc.ScaledObject, corev1.EventTypeNormal, eventreason.KEDAScalersInfo, message)
+			}
+		}
+	}
+}
+
 // paramsFromTag is a function that returns the Params struct based on the field tag
 func paramsFromTag(tag string, field reflect.StructField) (Params, error) {
 	params := Params{FieldName: field.Name}

pkg/scalers/scalersconfig/typed_config_test.go

@@ -613,15 +613,56 @@ func TestDeprecatedAnnounce(t *testing.T) {
 	Expect(mockRecorder.Message).To(Equal("Scaler  info: This parameter is deprecated. Use newParam instead"))
 }
 
+// TestUnexpectedOptional tests the unexpected optional input
+func TestUnexpectedOptional(t *testing.T) {
+	RegisterTestingT(t)
+
+	// Create a mock recorder to capture the event
+	mockRecorder := &MockEventRecorder{Messages: make([]string, 0)}
+
+	sc := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"stringVal":     "value1",
+			"nestVal":       "nestVal",
+			"notexistVal":   "aaa",
+			"notValFromEnv": "bbb",
+		},
+		ResolvedEnv: map[string]string{
+			"bbb": "1.1",
+		},
+		Recorder:           mockRecorder,
+		ScalableObjectType: "test",
+	}
+	type nestStruct struct {
+		Nest string `keda:"name=nestVal, order=triggerMetadata"`
+	}
+
+	type testStruct struct {
+		BA        nestStruct `keda:""`
+		StringVal string     `keda:"name=stringVal, order=triggerMetadata"`
+	}
+
+	ts := testStruct{}
+	err := sc.TypedConfig(&ts)
+	Expect(err).To(BeNil())
+
+	// Verify that the deprecation event was recorded
+	Expect(mockRecorder.EventCalled).To(BeTrue())
+	Expect(mockRecorder.Messages[0]).To(Equal("Unmatched input property notexistVal in scaler test"))
+	Expect(mockRecorder.Messages[1]).To(Equal("Unmatched input property notValFromEnv in scaler test"))
+}
+
 // MockEventRecorder is a mock implementation of record.EventRecorder
 type MockEventRecorder struct {
 	EventCalled bool
 	Message     string
+	Messages    []string
 }
 
 func (m *MockEventRecorder) Event(object runtime.Object, eventtype, reason, message string) {
 	m.EventCalled = true
 	m.Message = message
+	m.Messages = append(m.Messages, message)
 }
 
 func (m *MockEventRecorder) Eventf(object runtime.Object, eventtype, reason, messageFmt string, args ...interface{}) {