Improve error messages on bad [format] and [null_value] params for date mapper (#61932)

Currently, if an incorrectly formatted date is passed as a null_value for a date field mapper
configuration, you get a vague error:

Failed to parse mapping [_doc]: cannot parse empty date
Similarly, if you pass an incorrect format, you get the error:

Failed to parse mapping [_doc]: Invalid format [...]
This commit improves both these errors by including the mapper name and parameter that
are misconfigured.

Fixes #61712

Author: romseygeek

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

@@ -240,21 +240,36 @@ public boolean isFormatterSet() {
             return format.explicit();
         }
 
-        protected DateFieldType setupFieldType(BuilderContext context) {
+        private DateFormatter buildFormatter(BuilderContext context) {
             String pattern = this.format.value();
-            DateFormatter formatter;
-            if (Joda.isJodaPattern(context.indexCreatedVersion(), pattern)) {
-                formatter = Joda.forPattern(pattern).withLocale(locale);
-            } else {
-                formatter = DateFormatter.forPattern(pattern).withLocale(locale);
+            try {
+                if (Joda.isJodaPattern(context.indexCreatedVersion(), pattern)) {
+                    return Joda.forPattern(pattern).withLocale(locale);
+                } else {
+                    return DateFormatter.forPattern(pattern).withLocale(locale);
+                }
+            } catch (IllegalArgumentException e) {
+                throw new IllegalArgumentException("Error parsing [format] on field [" + name() + "]: " + e.getMessage(), e);
+            }
+        }
+
+        private Long parseNullValue(DateFormatter formatter) {
+            if (nullValue == null) {
+                return null;
+            }
+            try {
+                return formatter.parseMillis(nullValue);
+            }
+            catch (Exception e) {
+                throw new MapperParsingException("Error parsing [null_value] on field [" + name() + "]: " + e.getMessage(), e);
             }
-            return new DateFieldType(buildFullName(context), indexed, hasDocValues, formatter, resolution, meta);
         }
 
         @Override
         public DateFieldMapper build(BuilderContext context) {
-            DateFieldType ft = setupFieldType(context);
-            Long nullTimestamp = nullValue == null ? null : ft.dateTimeFormatter.parseMillis(nullValue);
+            DateFieldType ft = new DateFieldType(buildFullName(context), indexed, hasDocValues, buildFormatter(context), resolution, meta);
+
+            Long nullTimestamp = parseNullValue(ft.dateTimeFormatter);
             return new DateFieldMapper(name, fieldType, ft, ignoreMalformed(context), nullTimestamp, nullValue,
                 multiFieldsBuilder.build(this, context), copyTo);
         }

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

@@ -45,6 +45,7 @@
 import java.util.Set;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.notNullValue;
 
 public class DateFieldMapperTests extends FieldMapperTestCase<DateFieldMapper.Builder> {
@@ -332,7 +333,7 @@ public void testNullConfigValuesFail() throws MapperParsingException, IOExceptio
                 .endObject().endObject());
 
         Exception e = expectThrows(MapperParsingException.class, () -> parser.parse("type", new CompressedXContent(mapping)));
-        assertEquals("[format] must not have a [null] value", e.getMessage());
+        assertThat(e.getMessage(), containsString("[format] must not have a [null] value"));
     }
 
     public void testEmptyName() throws IOException {
@@ -347,6 +348,24 @@ public void testEmptyName() throws IOException {
         assertThat(e.getMessage(), containsString("name cannot be empty string"));
     }
 
+    public void testBadNullValue() throws IOException {
+
+        String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
+            .startObject("type")
+            .startObject("properties")
+            .startObject("field")
+            .field("type", "date")
+            .field("format", "")
+            .endObject()
+            .endObject()
+            .endObject().endObject());
+
+        Exception e = expectThrows(Exception.class, () -> parser.parse("type", new CompressedXContent(mapping)));
+
+        assertThat(e.getMessage(),
+            equalTo("Error parsing [format] on field [field]: No date pattern provided"));
+    }
+
     public void testTimeZoneParsing() throws Exception {
         final String timeZonePattern = "yyyy-MM-dd" + randomFrom("XXX", "[XXX]", "'['XXX']'");
 
@@ -435,7 +454,8 @@ public void testIllegalFormatField() throws Exception {
 
         IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
                 () -> parser.parse("type", new CompressedXContent(mapping)));
-        assertEquals("Invalid format: [[test_format]]: Unknown pattern letter: t", e.getMessage());
+        assertThat(e.getMessage(), containsString("Invalid format: [[test_format]]: Unknown pattern letter: t"));
+        assertThat(e.getMessage(), containsString("Error parsing [format] on field [field]: Invalid"));
     }
 
     public void testMeta() throws Exception {