Warn on badly-formed null values for date and IP field mappers (#62487)

In #57666 we changed when null_value was parsed for ip and date fields. Previously,
the null value was stored as a string, and parsed into a date or InetAddress whenever
a document containing a null value was encountered. Now, the values are parsed when
the mappings are built, which means that bad values are detected up front; if you try and
add a mapping with a badly-parsed ip or date for a null_value, the mapping will be
rejected.

This causes problems for upgrades in the case when you have a badly-formed null_value
in a pre-7.9 cluster. This commit fixes the upgrade case by changing the logic to only
logging a warning on the badly formed value, replicating the earlier behaviour.

Fixes #62363

Author: romseygeek

server/src/main/java/org/elasticsearch/index/mapper/DateFieldMapper.java

@@ -36,6 +36,7 @@
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.geo.ShapeRelation;
 import org.elasticsearch.common.joda.Joda;
+import org.elasticsearch.common.logging.DeprecationLogger;
 import org.elasticsearch.common.lucene.BytesRefs;
 import org.elasticsearch.common.time.DateFormatter;
 import org.elasticsearch.common.time.DateFormatters;
@@ -73,6 +74,8 @@
 /** A {@link FieldMapper} for dates. */
 public final class DateFieldMapper extends ParametrizedFieldMapper {
 
+    private static final DeprecationLogger DEPRECATION_LOGGER = DeprecationLogger.getLogger(DateFieldMapper.class);
+
     public static final String CONTENT_TYPE = "date";
     public static final String DATE_NANOS_CONTENT_TYPE = "date_nanos";
     public static final DateFormatter DEFAULT_DATE_TIME_FORMATTER = DateFormatter.forPattern("strict_date_optional_time||epoch_millis");
@@ -205,8 +208,8 @@ public static class Builder extends ParametrizedFieldMapper.Builder {
         private final Resolution resolution;
         private final Version indexCreatedVersion;
 
-        public Builder(String name, Version indexCreatedVersion, Resolution resolution,
-                       DateFormatter dateFormatter, boolean ignoreMalformedByDefault) {
+        public Builder(String name, Resolution resolution, DateFormatter dateFormatter,
+                       boolean ignoreMalformedByDefault, Version indexCreatedVersion) {
             super(name);
             this.resolution = resolution;
             this.indexCreatedVersion = indexCreatedVersion;
@@ -241,9 +244,10 @@ private Long parseNullValue(DateFieldType fieldType) {
             }
             try {
                 return fieldType.parse(nullValue.getValue());
-            }
-            catch (Exception e) {
-                throw new MapperParsingException("Error parsing [null_value] on field [" + name() + "]: " + e.getMessage(), e);
+            } catch (Exception e) {
+                DEPRECATION_LOGGER.deprecate("date_mapper_null_field", "Error parsing [" + nullValue.getValue()
+                        + "] as date in [null_value] on field [" + name() + "]); [null_value] will be ignored");
+                return null;
             }
         }
 
@@ -254,18 +258,18 @@ public DateFieldMapper build(BuilderContext context) {
             ft.setBoost(boost.getValue());
             Long nullTimestamp = parseNullValue(ft);
             return new DateFieldMapper(name, ft, multiFieldsBuilder.build(this, context),
-                copyTo.build(), nullTimestamp, resolution, indexCreatedVersion, this);
+                copyTo.build(), nullTimestamp, resolution, this);
         }
     }
 
     public static final TypeParser MILLIS_PARSER = new TypeParser((n, c) -> {
         boolean ignoreMalformedByDefault = IGNORE_MALFORMED_SETTING.get(c.getSettings());
-        return new Builder(n, c.indexVersionCreated(), Resolution.MILLISECONDS, c.getDateFormatter(), ignoreMalformedByDefault);
+        return new Builder(n, Resolution.MILLISECONDS, c.getDateFormatter(), ignoreMalformedByDefault, c.indexVersionCreated());
     });
 
     public static final TypeParser NANOS_PARSER = new TypeParser((n, c) -> {
         boolean ignoreMalformedByDefault = IGNORE_MALFORMED_SETTING.get(c.getSettings());
-        return new Builder(n, c.indexVersionCreated(), Resolution.NANOSECONDS, c.getDateFormatter(), ignoreMalformedByDefault);
+        return new Builder(n, Resolution.NANOSECONDS, c.getDateFormatter(), ignoreMalformedByDefault, c.indexVersionCreated());
     });
 
     public static final class DateFieldType extends MappedFieldType {
@@ -525,9 +529,9 @@ public DocValueFormat docValueFormat(@Nullable String format, ZoneId timeZone) {
     private final Long nullValue;
     private final String nullValueAsString;
     private final Resolution resolution;
-    private final Version indexCreatedVersion;
 
     private final boolean ignoreMalformedByDefault;
+    private final Version indexCreatedVersion;
 
     private DateFieldMapper(
             String simpleName,
@@ -536,7 +540,6 @@ private DateFieldMapper(
             CopyTo copyTo,
             Long nullValue,
             Resolution resolution,
-            Version indexCreatedVersion,
             Builder builder) {
         super(simpleName, mappedFieldType, multiFields, copyTo);
         this.store = builder.store.getValue();
@@ -548,13 +551,13 @@ private DateFieldMapper(
         this.nullValueAsString = builder.nullValue.getValue();
         this.nullValue = nullValue;
         this.resolution = resolution;
-        this.indexCreatedVersion = indexCreatedVersion;
         this.ignoreMalformedByDefault = builder.ignoreMalformed.getDefaultValue();
+        this.indexCreatedVersion = builder.indexCreatedVersion;
     }
 
     @Override
     public ParametrizedFieldMapper.Builder getMergeBuilder() {
-        return new Builder(simpleName(), indexCreatedVersion, resolution, null, ignoreMalformedByDefault).init(this);
+        return new Builder(simpleName(), resolution, null, ignoreMalformedByDefault, indexCreatedVersion).init(this);
     }
 
     @Override

server/src/main/java/org/elasticsearch/index/mapper/DocumentParser.java

@@ -696,9 +696,8 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(final ParseContex
                         = context.root().findTemplateBuilder(context, currentFieldName, dateTimeFormatter);
                     if (builder == null) {
                         boolean ignoreMalformed = IGNORE_MALFORMED_SETTING.get(context.indexSettings().getSettings());
-                        Version indexCreatedVersion = context.indexSettings().getIndexVersionCreated();
-                        builder = new DateFieldMapper.Builder(currentFieldName, indexCreatedVersion,
-                            DateFieldMapper.Resolution.MILLISECONDS, dateTimeFormatter, ignoreMalformed);
+                        builder = new DateFieldMapper.Builder(currentFieldName, DateFieldMapper.Resolution.MILLISECONDS,
+                            dateTimeFormatter, ignoreMalformed, Version.indexCreated(context.indexSettings().getSettings()));
                     }
                     return builder;
 

server/src/main/java/org/elasticsearch/index/mapper/IpFieldMapper.java

@@ -30,10 +30,11 @@
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.util.ArrayUtil;
 import org.apache.lucene.util.BytesRef;
+import org.elasticsearch.Version;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.collect.Tuple;
+import org.elasticsearch.common.logging.DeprecationLogger;
 import org.elasticsearch.common.network.InetAddresses;
-import org.elasticsearch.common.network.NetworkAddress;
 import org.elasticsearch.index.fielddata.IndexFieldData;
 import org.elasticsearch.index.fielddata.ScriptDocValues;
 import org.elasticsearch.index.fielddata.plain.SortedSetOrdinalsIndexFieldData;
@@ -55,6 +56,8 @@
 /** A {@link FieldMapper} for ip addresses. */
 public class IpFieldMapper extends ParametrizedFieldMapper {
 
+    private static final DeprecationLogger DEPRECATION_LOGGER = DeprecationLogger.getLogger(IpFieldMapper.class);
+
     public static final String CONTENT_TYPE = "ip";
 
     private static IpFieldMapper toType(FieldMapper in) {
@@ -68,36 +71,44 @@ public static class Builder extends ParametrizedFieldMapper.Builder {
         private final Parameter<Boolean> stored = Parameter.storeParam(m -> toType(m).stored, false);
 
         private final Parameter<Boolean> ignoreMalformed;
-        private final Parameter<InetAddress> nullValue = new Parameter<>("null_value", false, () -> null,
-            (n, c, o) -> o == null ? null : InetAddresses.forString(o.toString()), m -> toType(m).nullValue)
-            .setSerializer((b, f, v) -> {
-                if (v == null) {
-                    b.nullField(f);
-                } else {
-                    b.field(f, InetAddresses.toAddrString(v));
-                }
-            }, NetworkAddress::format)
-            .acceptsNull();
+        private final Parameter<String> nullValue
+            = Parameter.stringParam("null_value", false, m -> toType(m).nullValueAsString, null).acceptsNull();
 
         private final Parameter<Map<String, String>> meta = Parameter.metaParam();
 
         private final boolean ignoreMalformedByDefault;
+        private final Version indexCreatedVersion;
 
-        public Builder(String name, boolean ignoreMalformedByDefault) {
+        public Builder(String name, boolean ignoreMalformedByDefault, Version indexCreatedVersion) {
             super(name);
             this.ignoreMalformedByDefault = ignoreMalformedByDefault;
+            this.indexCreatedVersion = indexCreatedVersion;
             this.ignoreMalformed
                 = Parameter.boolParam("ignore_malformed", true, m -> toType(m).ignoreMalformed, ignoreMalformedByDefault);
         }
 
-        Builder nullValue(InetAddress nullValue) {
+        Builder nullValue(String nullValue) {
             this.nullValue.setValue(nullValue);
             return this;
         }
 
+        private InetAddress parseNullValue() {
+            String nullValueAsString = nullValue.getValue();
+            if (nullValueAsString == null) {
+                return null;
+            }
+            try {
+                return InetAddresses.forString(nullValueAsString);
+            } catch (Exception e) {
+                DEPRECATION_LOGGER.deprecate("ip_mapper_null_field", "Error parsing [" + nullValue.getValue()
+                    + "] as IP in [null_value] on field [" + name() + "]); [null_value] will be ignored");
+                return null;
+            }
+        }
+
         @Override
         protected List<Parameter<?>> getParameters() {
-            return Arrays.asList(indexed, hasDocValues, stored, ignoreMalformed, nullValue);
+            return Arrays.asList(indexed, hasDocValues, stored, ignoreMalformed, nullValue, meta);
         }
 
         @Override
@@ -111,7 +122,7 @@ public IpFieldMapper build(BuilderContext context) {
 
     public static final TypeParser PARSER = new TypeParser((n, c) -> {
         boolean ignoreMalformedByDefault = IGNORE_MALFORMED_SETTING.get(c.getSettings());
-        return new Builder(n, ignoreMalformedByDefault);
+        return new Builder(n, ignoreMalformedByDefault, c.indexVersionCreated());
     });
 
     public static final class IpFieldType extends SimpleMappedFieldType {
@@ -322,9 +333,12 @@ public DocValueFormat docValueFormat(@Nullable String format, ZoneId timeZone) {
     private final boolean hasDocValues;
     private final boolean stored;
     private final boolean ignoreMalformed;
+
     private final InetAddress nullValue;
+    private final String nullValueAsString;
 
     private final boolean ignoreMalformedByDefault;
+    private final Version indexCreatedVersion;
 
     private IpFieldMapper(
             String simpleName,
@@ -338,7 +352,9 @@ private IpFieldMapper(
         this.hasDocValues = builder.hasDocValues.getValue();
         this.stored = builder.stored.getValue();
         this.ignoreMalformed = builder.ignoreMalformed.getValue();
-        this.nullValue = builder.nullValue.getValue();
+        this.nullValue = builder.parseNullValue();
+        this.nullValueAsString = builder.nullValue.getValue();
+        this.indexCreatedVersion = builder.indexCreatedVersion;
     }
 
     @Override
@@ -424,6 +440,6 @@ protected Object parseSourceValue(Object value) {
 
     @Override
     public ParametrizedFieldMapper.Builder getMergeBuilder() {
-        return new Builder(simpleName(), ignoreMalformedByDefault).init(this);
+        return new Builder(simpleName(), ignoreMalformedByDefault, indexCreatedVersion).init(this);
     }
 }

server/src/test/java/org/elasticsearch/action/admin/indices/rollover/MetadataRolloverServiceTests.java

@@ -554,7 +554,7 @@ public void testRolloverClusterStateForDataStream() throws Exception {
         try {
             Mapper.BuilderContext builderContext = new Mapper.BuilderContext(Settings.EMPTY, new ContentPath(0));
             DateFieldMapper dateFieldMapper
-                = new DateFieldMapper.Builder("@timestamp", Version.CURRENT, DateFieldMapper.Resolution.MILLISECONDS, null, false)
+                = new DateFieldMapper.Builder("@timestamp", DateFieldMapper.Resolution.MILLISECONDS, null, false, Version.CURRENT)
                 .build(builderContext);
             MetadataFieldMapper mockedTimestampField = mock(MetadataFieldMapper.class);
             when(mockedTimestampField.name()).thenReturn("_data_stream_timestamp");

server/src/test/java/org/elasticsearch/index/mapper/DateFieldMapperTests.java

@@ -40,7 +40,6 @@
 import java.util.Map;
 
 import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.notNullValue;
 
 public class DateFieldMapperTests extends MapperTestCase {
@@ -221,14 +220,10 @@ public void testNanosNullValue() throws IOException {
         assertFalse(dvField.fieldType().stored());
     }
 
-    public void testBadNullValue() {
+    public void testBadNullValue() throws IOException {
+        createDocumentMapper(fieldMapping(b -> b.field("type", "date").field("null_value", "foo")));
 
-        MapperParsingException e = expectThrows(MapperParsingException.class,
-            () -> createDocumentMapper(fieldMapping(b -> b.field("type", "date").field("null_value", ""))));
-
-        assertThat(e.getMessage(),
-            equalTo("Failed to parse mapping [_doc]: Error parsing [null_value] on field [field]: cannot parse empty date"));
-    }
+        assertWarnings("Error parsing [foo] as date in [null_value] on field [field]); [null_value] will be ignored"); }
 
     public void testNullConfigValuesFail() {
         Exception e = expectThrows(MapperParsingException.class,
@@ -364,7 +359,8 @@ private DateFieldMapper createMapper(Resolution resolution, String format, Strin
             mapping.put("null_value", nullValue);
         }
 
-        DateFieldMapper.Builder builder = new DateFieldMapper.Builder("field", Version.CURRENT, resolution, null, false);
+        DateFieldMapper.Builder builder
+            = new DateFieldMapper.Builder("field", resolution, null, false, Version.CURRENT);
         builder.parse("field", null, mapping);
         return builder.build(context);
     }