Add support for constant_keyword "value" in field definition

internal/fields/model.go

@@ -9,6 +9,7 @@ type FieldDefinition struct {
 Name string `yaml:"name"`
 Description string `yaml:"description"`
 Type string `yaml:"type"`
+Value string `yaml:"value"` // The value to associate with a constant_keyword field.
 Pattern string `yaml:"pattern"`
 Unit string `yaml:"unit"`
 MetricType string `yaml:"metric_type"`

internal/fields/testdata/constant-keyword-invalid.json

@@ -0,0 +1,5 @@
+{
+ "foo": {
+ "constant": "wrong"
+ }
+}

internal/fields/testdata/constant-keyword-valid.json

@@ -0,0 +1,5 @@
+{
+ "foo": {
+ "constant": "correct"
+ }
+}

internal/fields/testdata/fields/fields.yml

@@ -8,3 +8,6 @@
  fields:
  - name: request_parameters
  type: flattened
+ - name: constant
+ type: constant_keyword
+ value: correct

internal/fields/validate.go

@@ -293,19 +293,28 @@ func (v *Validator) parseElementValue(key string, definition FieldDefinition, va
 
 var valid bool
 switch definition.Type {
-case "date", "ip", "constant_keyword", "keyword", "text":
+case "constant_keyword":
 var valStr string
 valStr, valid = val.(string)
-if !valid || definition.Pattern == "" {
+if !valid {
 break
 }
 
-valid, err := regexp.MatchString(definition.Pattern, valStr)
-if err != nil {
-return errors.Wrap(err, "invalid pattern")
+if err := ensureConstantKeywordValueMatches(key, valStr, definition.Value); err != nil {
+return err
+}
+if err := ensurePatternMatches(key, valStr, definition.Pattern); err != nil {
+return err
 }
+case "date", "ip", "keyword", "text":
+var valStr string
+valStr, valid = val.(string)
 if !valid {
-return fmt.Errorf("field %q's value, %s, does not match the expected pattern: %s", key, valStr, definition.Pattern)
+break
+}
+
+if err := ensurePatternMatches(key, valStr, definition.Pattern); err != nil {
+return err
 }
 case "float", "long", "double":
 _, valid = val.(float64)
@@ -331,3 +340,31 @@ func ensureSingleElementValue(val interface{}) (interface{}, bool) {
 }
 return nil, false // false: empty array, can't deduce single value type
 }
+
+// ensurePatternMatches validates the document's field value matches the field
+// definitions regular expression pattern.
+func ensurePatternMatches(key, value, pattern string) error {
+if pattern == "" {
+return nil
+}
+valid, err := regexp.MatchString(pattern, value)
+if err != nil {
+return errors.Wrap(err, "invalid pattern")
+}
+if !valid {
+return fmt.Errorf("field %q's value, %s, does not match the expected pattern: %s", key, value, pattern)
+}
+return nil
+}
+
+// ensureConstantKeywordValueMatches validates the document's field value
+// matches the definition's constant_keyword value.
+func ensureConstantKeywordValueMatches(key, value, constantKeywordValue string) error {
+if constantKeywordValue == "" {
+return nil
+}
+if value != constantKeywordValue {
+return fmt.Errorf("field %q's value %q does not match the declared constant_keyword value %q", key, value, constantKeywordValue)
+}
+return nil
+}

internal/fields/validate_test.go

@@ -61,6 +61,20 @@ func TestValidate_WithNumericKeywordFields(t *testing.T) {
 require.Empty(t, errs)
 }
 
+func TestValidate_constant_keyword(t *testing.T) {
+validator, err := CreateValidatorForDataStream("testdata")
+require.NoError(t, err)
+require.NotNil(t, validator)
+
+e := readSampleEvent(t, "testdata/constant-keyword-invalid.json")
+errs := validator.ValidateDocumentBody(e)
+require.NotEmpty(t, errs)
+
+e = readSampleEvent(t, "testdata/constant-keyword-valid.json")
+errs = validator.ValidateDocumentBody(e)
+require.Empty(t, errs)
+}
+
 func Test_parseElementValue(t *testing.T) {
 for _, test := range []struct {
 key string