Add some utility functions for handling Maxmind geoip results (#125153) (#125165)

joegallo · web-flow · commit e052ad92ac65 · 2025-03-19T09:22:51.000+11:00
diff --git a/modules/ingest-geoip/src/main/java/org/elasticsearch/ingest/geoip/MaxmindIpDataLookups.java b/modules/ingest-geoip/src/main/java/org/elasticsearch/ingest/geoip/MaxmindIpDataLookups.java
@@ -209,9 +209,9 @@ protected Map<String, Object> transform(final CityResponse response) {
                 switch (property) {
                     case IP -> data.put("ip", response.getTraits().getIpAddress());
                     case COUNTRY_IN_EUROPEAN_UNION -> {
-                        if (country.getIsoCode() != null) {
-                            // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country
-                            data.put("country_in_european_union", country.isInEuropeanUnion());
+                        Boolean isInEuropeanUnion = isInEuropeanUnion(country);
+                        if (isInEuropeanUnion != null) {
+                            data.put("country_in_european_union", isInEuropeanUnion);
                         }
                     }
                     case COUNTRY_ISO_CODE -> {
@@ -239,12 +239,8 @@ protected Map<String, Object> transform(final CityResponse response) {
                         }
                     }
                     case REGION_ISO_CODE -> {
-                        // ISO 3166-2 code for country subdivisions.
-                        // See iso.org/iso-3166-country-codes.html
-                        String countryIso = country.getIsoCode();
-                        String subdivisionIso = subdivision.getIsoCode();
-                        if (countryIso != null && subdivisionIso != null) {
-                            String regionIsoCode = countryIso + "-" + subdivisionIso;
+                        String regionIsoCode = regionIsoCode(country, subdivision);
+                        if (regionIsoCode != null) {
                             data.put("region_iso_code", regionIsoCode);
                         }
                     }
@@ -288,9 +284,9 @@ protected Map<String, Object> transform(final CityResponse response) {
                         }
                     }
                     case REGISTERED_COUNTRY_IN_EUROPEAN_UNION -> {
-                        if (registeredCountry.getIsoCode() != null) {
-                            // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country
-                            data.put("registered_country_in_european_union", registeredCountry.isInEuropeanUnion());
+                        Boolean isInEuropeanUnion = isInEuropeanUnion(registeredCountry);
+                        if (isInEuropeanUnion != null) {
+                            data.put("registered_country_in_european_union", isInEuropeanUnion);
                         }
                     }
                     case REGISTERED_COUNTRY_ISO_CODE -> {
@@ -353,9 +349,9 @@ protected Map<String, Object> transform(final CountryResponse response) {
                 switch (property) {
                     case IP -> data.put("ip", response.getTraits().getIpAddress());
                     case COUNTRY_IN_EUROPEAN_UNION -> {
-                        if (country.getIsoCode() != null) {
-                            // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country
-                            data.put("country_in_european_union", country.isInEuropeanUnion());
+                        Boolean isInEuropeanUnion = isInEuropeanUnion(country);
+                        if (isInEuropeanUnion != null) {
+                            data.put("country_in_european_union", isInEuropeanUnion);
                         }
                     }
                     case COUNTRY_ISO_CODE -> {
@@ -383,9 +379,9 @@ protected Map<String, Object> transform(final CountryResponse response) {
                         }
                     }
                     case REGISTERED_COUNTRY_IN_EUROPEAN_UNION -> {
-                        if (registeredCountry.getIsoCode() != null) {
-                            // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country
-                            data.put("registered_country_in_european_union", registeredCountry.isInEuropeanUnion());
+                        Boolean isInEuropeanUnion = isInEuropeanUnion(registeredCountry);
+                        if (isInEuropeanUnion != null) {
+                            data.put("registered_country_in_european_union", isInEuropeanUnion);
                         }
                     }
                     case REGISTERED_COUNTRY_ISO_CODE -> {
@@ -480,9 +476,9 @@ protected Map<String, Object> transform(final EnterpriseResponse response) {
                         }
                     }
                     case COUNTRY_IN_EUROPEAN_UNION -> {
-                        if (country.getIsoCode() != null) {
-                            // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country
-                            data.put("country_in_european_union", country.isInEuropeanUnion());
+                        Boolean isInEuropeanUnion = isInEuropeanUnion(country);
+                        if (isInEuropeanUnion != null) {
+                            data.put("country_in_european_union", isInEuropeanUnion);
                         }
                     }
                     case COUNTRY_ISO_CODE -> {
@@ -510,12 +506,8 @@ protected Map<String, Object> transform(final EnterpriseResponse response) {
                         }
                     }
                     case REGION_ISO_CODE -> {
-                        // ISO 3166-2 code for country subdivisions.
-                        // See iso.org/iso-3166-country-codes.html
-                        String countryIso = country.getIsoCode();
-                        String subdivisionIso = subdivision.getIsoCode();
-                        if (countryIso != null && subdivisionIso != null) {
-                            String regionIsoCode = countryIso + "-" + subdivisionIso;
+                        String regionIsoCode = regionIsoCode(country, subdivision);
+                        if (regionIsoCode != null) {
                             data.put("region_iso_code", regionIsoCode);
                         }
                     }
@@ -639,9 +631,9 @@ protected Map<String, Object> transform(final EnterpriseResponse response) {
                         }
                     }
                     case REGISTERED_COUNTRY_IN_EUROPEAN_UNION -> {
-                        if (registeredCountry.getIsoCode() != null) {
-                            // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country
-                            data.put("registered_country_in_european_union", registeredCountry.isInEuropeanUnion());
+                        Boolean isInEuropeanUnion = isInEuropeanUnion(registeredCountry);
+                        if (isInEuropeanUnion != null) {
+                            data.put("registered_country_in_european_union", isInEuropeanUnion);
                         }
                     }
                     case REGISTERED_COUNTRY_ISO_CODE -> {
@@ -776,4 +768,23 @@ private RESPONSE lookup(final Reader reader, final String ipAddress) throws IOEx
          */
         protected abstract Map<String, Object> transform(RESPONSE response);
     }
+
+    @Nullable
+    private static Boolean isInEuropeanUnion(com.maxmind.geoip2.record.Country country) {
+        // isInEuropeanUnion is a lowercase-b boolean so it cannot be null, but it really only makes sense for us to return a value
+        // for this if there's actually a real country here, as opposed to an empty null-object country, so we check for an iso code first
+        return (country.getIsoCode() == null) ? null : country.isInEuropeanUnion();
+    }
+
+    @Nullable
+    private static String regionIsoCode(final com.maxmind.geoip2.record.Country country, final Subdivision subdivision) {
+        // ISO 3166-2 code for country subdivisions, see https://www.iso.org/iso-3166-country-codes.html
+        final String countryIso = country.getIsoCode();
+        final String subdivisionIso = subdivision.getIsoCode();
+        if (countryIso != null && subdivisionIso != null) {
+            return countryIso + "-" + subdivisionIso;
+        } else {
+            return null;
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -209,9 +209,9 @@ protected Map<String, Object> transform(final CityResponse response) {`
`209`	`209`	`switch (property) {`
`210`	`210`	`case IP -> data.put("ip", response.getTraits().getIpAddress());`
`211`	`211`	`case COUNTRY_IN_EUROPEAN_UNION -> {`
`212`		`- if (country.getIsoCode() != null) {`
`213`		`- // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country`
`214`		`- data.put("country_in_european_union", country.isInEuropeanUnion());`
	`212`	`+ Boolean isInEuropeanUnion = isInEuropeanUnion(country);`
	`213`	`+ if (isInEuropeanUnion != null) {`
	`214`	`+ data.put("country_in_european_union", isInEuropeanUnion);`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`	`case COUNTRY_ISO_CODE -> {`
`@@ -239,12 +239,8 @@ protected Map<String, Object> transform(final CityResponse response) {`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`	`case REGION_ISO_CODE -> {`
`242`		`- // ISO 3166-2 code for country subdivisions.`
`243`		`- // See iso.org/iso-3166-country-codes.html`
`244`		`- String countryIso = country.getIsoCode();`
`245`		`- String subdivisionIso = subdivision.getIsoCode();`
`246`		`- if (countryIso != null && subdivisionIso != null) {`
`247`		`- String regionIsoCode = countryIso + "-" + subdivisionIso;`
	`242`	`+ String regionIsoCode = regionIsoCode(country, subdivision);`
	`243`	`+ if (regionIsoCode != null) {`
`248`	`244`	`data.put("region_iso_code", regionIsoCode);`
`249`	`245`	`}`
`250`	`246`	`}`
`@@ -288,9 +284,9 @@ protected Map<String, Object> transform(final CityResponse response) {`
`288`	`284`	`}`
`289`	`285`	`}`
`290`	`286`	`case REGISTERED_COUNTRY_IN_EUROPEAN_UNION -> {`
`291`		`- if (registeredCountry.getIsoCode() != null) {`
`292`		`- // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country`
`293`		`- data.put("registered_country_in_european_union", registeredCountry.isInEuropeanUnion());`
	`287`	`+ Boolean isInEuropeanUnion = isInEuropeanUnion(registeredCountry);`
	`288`	`+ if (isInEuropeanUnion != null) {`
	`289`	`+ data.put("registered_country_in_european_union", isInEuropeanUnion);`
`294`	`290`	`}`
`295`	`291`	`}`
`296`	`292`	`case REGISTERED_COUNTRY_ISO_CODE -> {`
`@@ -353,9 +349,9 @@ protected Map<String, Object> transform(final CountryResponse response) {`
`353`	`349`	`switch (property) {`
`354`	`350`	`case IP -> data.put("ip", response.getTraits().getIpAddress());`
`355`	`351`	`case COUNTRY_IN_EUROPEAN_UNION -> {`
`356`		`- if (country.getIsoCode() != null) {`
`357`		`- // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country`
`358`		`- data.put("country_in_european_union", country.isInEuropeanUnion());`
	`352`	`+ Boolean isInEuropeanUnion = isInEuropeanUnion(country);`
	`353`	`+ if (isInEuropeanUnion != null) {`
	`354`	`+ data.put("country_in_european_union", isInEuropeanUnion);`
`359`	`355`	`}`
`360`	`356`	`}`
`361`	`357`	`case COUNTRY_ISO_CODE -> {`
`@@ -383,9 +379,9 @@ protected Map<String, Object> transform(final CountryResponse response) {`
`383`	`379`	`}`
`384`	`380`	`}`
`385`	`381`	`case REGISTERED_COUNTRY_IN_EUROPEAN_UNION -> {`
`386`		`- if (registeredCountry.getIsoCode() != null) {`
`387`		`- // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country`
`388`		`- data.put("registered_country_in_european_union", registeredCountry.isInEuropeanUnion());`
	`382`	`+ Boolean isInEuropeanUnion = isInEuropeanUnion(registeredCountry);`
	`383`	`+ if (isInEuropeanUnion != null) {`
	`384`	`+ data.put("registered_country_in_european_union", isInEuropeanUnion);`
`389`	`385`	`}`
`390`	`386`	`}`
`391`	`387`	`case REGISTERED_COUNTRY_ISO_CODE -> {`
`@@ -480,9 +476,9 @@ protected Map<String, Object> transform(final EnterpriseResponse response) {`
`480`	`476`	`}`
`481`	`477`	`}`
`482`	`478`	`case COUNTRY_IN_EUROPEAN_UNION -> {`
`483`		`- if (country.getIsoCode() != null) {`
`484`		`- // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country`
`485`		`- data.put("country_in_european_union", country.isInEuropeanUnion());`
	`479`	`+ Boolean isInEuropeanUnion = isInEuropeanUnion(country);`
	`480`	`+ if (isInEuropeanUnion != null) {`
	`481`	`+ data.put("country_in_european_union", isInEuropeanUnion);`
`486`	`482`	`}`
`487`	`483`	`}`
`488`	`484`	`case COUNTRY_ISO_CODE -> {`
`@@ -510,12 +506,8 @@ protected Map<String, Object> transform(final EnterpriseResponse response) {`
`510`	`506`	`}`
`511`	`507`	`}`
`512`	`508`	`case REGION_ISO_CODE -> {`
`513`		`- // ISO 3166-2 code for country subdivisions.`
`514`		`- // See iso.org/iso-3166-country-codes.html`
`515`		`- String countryIso = country.getIsoCode();`
`516`		`- String subdivisionIso = subdivision.getIsoCode();`
`517`		`- if (countryIso != null && subdivisionIso != null) {`
`518`		`- String regionIsoCode = countryIso + "-" + subdivisionIso;`
	`509`	`+ String regionIsoCode = regionIsoCode(country, subdivision);`
	`510`	`+ if (regionIsoCode != null) {`
`519`	`511`	`data.put("region_iso_code", regionIsoCode);`
`520`	`512`	`}`
`521`	`513`	`}`
`@@ -639,9 +631,9 @@ protected Map<String, Object> transform(final EnterpriseResponse response) {`
`639`	`631`	`}`
`640`	`632`	`}`
`641`	`633`	`case REGISTERED_COUNTRY_IN_EUROPEAN_UNION -> {`
`642`		`- if (registeredCountry.getIsoCode() != null) {`
`643`		`- // isInEuropeanUnion is a boolean so it can't be null. But it really only makes sense if we have a country`
`644`		`- data.put("registered_country_in_european_union", registeredCountry.isInEuropeanUnion());`
	`634`	`+ Boolean isInEuropeanUnion = isInEuropeanUnion(registeredCountry);`
	`635`	`+ if (isInEuropeanUnion != null) {`
	`636`	`+ data.put("registered_country_in_european_union", isInEuropeanUnion);`
`645`	`637`	`}`
`646`	`638`	`}`
`647`	`639`	`case REGISTERED_COUNTRY_ISO_CODE -> {`
`@@ -776,4 +768,23 @@ private RESPONSE lookup(final Reader reader, final String ipAddress) throws IOEx`
`776`	`768`	`*/`
`777`	`769`	`protected abstract Map<String, Object> transform(RESPONSE response);`
`778`	`770`	`}`
	`771`	`+`
	`772`	`+ @Nullable`
	`773`	`+ private static Boolean isInEuropeanUnion(com.maxmind.geoip2.record.Country country) {`
	`774`	`+ // isInEuropeanUnion is a lowercase-b boolean so it cannot be null, but it really only makes sense for us to return a value`
	`775`	`+ // for this if there's actually a real country here, as opposed to an empty null-object country, so we check for an iso code first`
	`776`	`+ return (country.getIsoCode() == null) ? null : country.isInEuropeanUnion();`
	`777`	`+ }`
	`778`	`+`
	`779`	`+ @Nullable`
	`780`	`+ private static String regionIsoCode(final com.maxmind.geoip2.record.Country country, final Subdivision subdivision) {`
	`781`	`+ // ISO 3166-2 code for country subdivisions, see https://www.iso.org/iso-3166-country-codes.html`
	`782`	`+ final String countryIso = country.getIsoCode();`
	`783`	`+ final String subdivisionIso = subdivision.getIsoCode();`
	`784`	`+ if (countryIso != null && subdivisionIso != null) {`
	`785`	`+ return countryIso + "-" + subdivisionIso;`
	`786`	`+ } else {`
	`787`	`+ return null;`
	`788`	`+ }`
	`789`	`+ }`
`779`	`790`	`}`