Unify and improve country info

intel/entity.go

@@ -251,7 +251,7 @@ func (e *Entity) getLocation(ctx context.Context) {
 			return
 		}
 		e.location = loc
-		e.Country = loc.Country.ISOCode
+		e.Country = loc.Country.Code
 		e.Coordinates = &loc.Coordinates
 		e.ASN = loc.AutonomousSystemNumber
 		e.ASOrg = loc.AutonomousSystemOrganization
@@ -272,9 +272,10 @@ func (e *Entity) getLocation(ctx context.Context) {
 
 			// Log location
 			log.Tracer(ctx).Tracef(
-				"intel: located %s in %s (AS%d by %s)%s",
+				"intel: located %s in %s (%s), as part of AS%d by %s%s",
 				e.IP,
-				loc.Country.ISOCode,
+				loc.Country.Name,
+				loc.Country.Code,
 				loc.AutonomousSystemNumber,
 				loc.AutonomousSystemOrganization,
 				flags,
@@ -303,6 +304,16 @@ func (e *Entity) GetCountry(ctx context.Context) (string, bool) {
 	return e.Country, true
 }
 
+// GetCountryInfo returns the two letter ISO country code and whether it is set.
+func (e *Entity) GetCountryInfo(ctx context.Context) *geoip.CountryInfo {
+	e.getLocation(ctx)
+
+	if e.LocationError != "" {
+		return nil
+	}
+	return &e.location.Country
+}
+
 // GetASN returns the AS number and whether it is set.
 func (e *Entity) GetASN(ctx context.Context) (uint, bool) {
 	e.getLocation(ctx)

intel/geoip/country_info_test.go

@@ -1,6 +1,7 @@
 package geoip
 
 import (
+	"strings"
 	"testing"
 )
 
@@ -8,21 +9,31 @@ func TestCountryInfo(t *testing.T) {
 	t.Parallel()
 
 	for key, country := range countries {
-		if key != country.ID {
-			t.Errorf("%s has a wrong ID of %q", key, country.ID)
+		if key != country.Code {
+			t.Errorf("%s has a wrong country code of %q", key, country.Code)
 		}
 		if country.Name == "" {
 			t.Errorf("%s is missing name", key)
 		}
-		if country.Region == "" {
-			t.Errorf("%s is missing region", key)
-		}
-		if country.ContinentCode == "" {
+		if country.Continent.Code == "" {
 			t.Errorf("%s is missing continent", key)
 		}
+		if country.Continent.Region == "" {
+			t.Errorf("%s is missing continent region", key)
+		}
+		if country.Continent.Name == "" {
+			t.Errorf("%s is missing continent name", key)
+		}
+		generatedContinentCode, _, _ := strings.Cut(country.Continent.Region, "-")
+		if country.Continent.Code != generatedContinentCode {
+			t.Errorf("%s is has wrong continent code or region", key)
+		}
 		if country.Center.Latitude == 0 && country.Center.Longitude == 0 {
 			t.Errorf("%s is missing coords", key)
 		}
+		if country.Center.AccuracyRadius == 0 {
+			t.Errorf("%s is missing accuracy radius", key)
+		}
 
 		// Generate map source from data:
 		// fmt.Printf(

intel/geoip/location.go

@@ -18,13 +18,7 @@ const (
 // Location holds information regarding the geographical and network location of an IP address.
 // TODO: We are currently re-using the Continent-Code for the region. Update this and all dependencies.
 type Location struct {
-	Continent struct {
-		Code string `maxminddb:"code"`
-	} `maxminddb:"continent"`
-	Country struct {
-		Name    string
-		ISOCode string `maxminddb:"iso_code"`
-	} `maxminddb:"country"`
+	Country                      CountryInfo `maxminddb:"country"`
 	Coordinates                  Coordinates `maxminddb:"location"`
 	AutonomousSystemNumber       uint        `maxminddb:"autonomous_system_number"`
 	AutonomousSystemOrganization string      `maxminddb:"autonomous_system_organization"`
@@ -96,10 +90,9 @@ const (
 // EstimateNetworkProximity aims to calculate the distance between two network locations. Returns a proximity value between 0 (far away) and 100 (nearby).
 func (l *Location) EstimateNetworkProximity(to *Location) (proximity float32) {
 	switch {
-	case l.Country.ISOCode != "" && l.Country.ISOCode == to.Country.ISOCode:
+	case l.Country.Code != "" && l.Country.Code == to.Country.Code:
 		proximity += weightCountryMatch + weightRegionMatch + weightRegionalNeighborMatch
-	case l.Continent.Code != "" && l.Continent.Code == to.Continent.Code:
-		// FYI: This is the region code!
+	case l.Country.Continent.Region != "" && l.Country.Continent.Region == to.Country.Continent.Region:
 		proximity += weightRegionMatch + weightRegionalNeighborMatch
 	case l.IsRegionalNeighbor(to):
 		proximity += weightRegionalNeighborMatch

intel/geoip/regions.go

@@ -6,11 +6,11 @@ import (
 
 // IsRegionalNeighbor returns whether the supplied location is a regional neighbor.
 func (l *Location) IsRegionalNeighbor(other *Location) bool {
-	if l.Continent.Code == "" || other.Continent.Code == "" {
+	if l.Country.Continent.Region == "" || other.Country.Continent.Region == "" {
 		return false
 	}
-	if region, ok := regions[l.Continent.Code]; ok {
-		return utils.StringInSlice(region.Neighbors, other.Continent.Code)
+	if region, ok := regions[l.Country.Continent.Region]; ok {
+		return utils.StringInSlice(region.Neighbors, other.Country.Continent.Region)
 	}
 	return false
 }