
Intro #
Nginx access log enrichment adds valuable IP intelligence to standard web server logs, helping administrators understand where website visitors come from and identify potentially anonymous connections. While Nginx access logs record visitor IP addresses, requested URLs, HTTP status codes, and user agents, they do not inherently provide geographic information or indicate whether connections originate from VPNs, proxy servers, or other anonymizing services.
By combining Vector with IP2Location and IP2Proxy MMDB databases, administrators can enrich Nginx access logs with additional IP intelligence before storing or forwarding them for analysis.
Vector is an open-source observability data pipeline developed by Datadog. It can collect logs from different sources, transform and enrich records, and forward the processed data to destinations such as local files, Elasticsearch, or cloud storage.
In this tutorial, we will use Vector’s built-in geoip enrichment table type to integrate two databases:
- IP2Location LITE DB11 MMDB: A free IP geolocation database providing country, region, city, latitude, longitude, ZIP code, and time zone information.
- IP2Proxy Commercial PX10 MMDB: A commercial IP intelligence database that identifies anonymous connections, including VPNs, public proxies, hosting providers, residential proxies, and Tor exit nodes.
Both databases use MMDB formats compatible with MaxMind database structures. DB11 LITE follows the GeoLite2-City schema, while PX10 MMDB follows the GeoIP2-Anonymous-IP schema.
The demonstration will use Nginx as the web server, Vector as the log processing engine, and a local JSON Lines file as the destination for enriched logs.
By the end of this tutorial, you will have a working pipeline that automatically reads Nginx access logs, extracts visitor IP addresses, performs local MMDB lookups using both databases, and writes enriched JSON records to a separate log file.
Architecture overview #
The demonstration consists of four components.
| Component | Role |
| Nginx | Generates web access logs |
| Vector | Collects, parses, and enriches the access logs |
| IP2Location DB11 LITE MMDB | Supplies IP geolocation information |
| IP2Proxy PX10 MMDB | Supplies anonymous-IP detection information |
The processing sequence is straightforward:
- A visitor makes an HTTP request to Nginx.
- Nginx writes the request information to its access log.
- Vector reads the access log and extracts the visitor’s IP address.
- Vector queries both MMDB databases using the
geoipenrichment tables. - The enriched log record is written to a local JSON Lines file for inspection or further processing.
All IP lookups are performed locally. There is no need to call an external IP geolocation API for every request.
Prerequisites #
This tutorial assumes the following environment:
| Requirement | Details |
| Operating system | Debian 13 (Trixie) |
| User account | An account with sudo privileges |
| Web server | Nginx |
| Log processor | Vector |
| Geolocation database | IP2Location LITE DB11 MMDB |
| Proxy detection database | IP2Proxy Commercial PX10 MMDB |
| Destination | Local JSON Lines log file |
You will also need an IP2Location account to download the DB11 LITE MMDB and a valid commercial PX10 subscription.
The instructions below use a dedicated Nginx demonstration server listening on 127.0.0.1:8080. This avoids interfering with an existing website and keeps the demonstration endpoint local.
Step 1: Update Debian #
First, update the package lists:
sudo apt update
Optionally, upgrade installed packages:
sudo apt upgrade -y
Install the required utilities:
sudo apt install -y curl ca-certificates gnupg unzip jq mmdb-bin
These packages provide tools for downloading files, inspecting JSON output, and testing MMDB databases.
Step 2: Install Nginx #
Install Nginx using the Debian package manager:
sudo apt install -y nginx
Enable Nginx and start it:
sudo systemctl enable --now nginx
Verify that the service is running:
sudo systemctl status nginx
The service should show active (running).

Nginx normally stores its access logs in /var/log/nginx/access.log.
For this tutorial, we will create a separate access log for the demonstration so that it does not interfere with your existing Nginx logs.
Step 3: Create an Nginx demonstration website #
Create a dedicated Nginx server configuration:
sudo nano /etc/nginx/sites-available/vector-demo
Add the following configuration:
server {
listen 127.0.0.1:8080;
server_name localhost;
access_log /var/log/nginx/vector-demo-access.log combined;
error_log /var/log/nginx/vector-demo-error.log;
location / {
default_type text/plain;
return 200 "Nginx Vector MMDB Demo\n";
}
}
This configuration creates an HTTP server on port 8080.
Every request will be recorded in the dedicated vector-demo-access.log file using Nginx’s standard combined log format.
Enable the demonstration site:
sudo ln -s /etc/nginx/sites-available/vector-demo \
 /etc/nginx/sites-enabled/vector-demo
Test the Nginx configuration:
sudo nginx -t
If the syntax check succeeds, reload Nginx:
sudo systemctl reload nginx
Send a test request:
curl http://127.0.0.1:8080/
Expected response:
Nginx Vector MMDB Demo
Check the generated access log:
sudo tail -n 5 /var/log/nginx/vector-demo-access.log
An example entry looks like this:

The log contains the client’s IP address, timestamp, HTTP method, URL, status code, response size, referrer, and user agent.
At this stage, the log does not contain geographic information or proxy detection results.
Because this test originates from localhost, the recorded IP address is 127.0.0.1. We will later add a synthetic log entry containing a public IP address to verify the MMDB enrichment.
Step 4: Install Vector #
Vector provides an official APT repository for Debian and Ubuntu systems.
Add the repository using Vector’s installation script:
bash -c "$(curl -L https://setup.vector.dev)"
This script configures the APT repository and its signing key.
Update the package lists:
sudo apt update
Install Vector:
sudo apt install -y vector
Verify the installation:
vector –version

Check whether Vector has installed its systemd service:
sudo systemctl status vector

We will replace the default configuration before starting the processing pipeline.
If Vector is already running with its default configuration, stop it temporarily:
sudo systemctl stop vector
Step 5: Download the required MMDB files #
IP2Location LITE DB11 MMDB provides city-level IP geolocation information.
It includes fields such as:
| Field | Description |
| Country code | Two-letter country identifier |
| Country name | Name of the country |
| Region | State or province |
| City | City name |
| Latitude | Approximate geographic latitude |
| Longitude | Approximate geographic longitude |
| Postal code | ZIP or postal code |
| Time zone | Associated time zone |
IP2Proxy PX10 focuses on anonymous-IP and proxy detection.
The commercial PX10 database includes a broader range of proxy intelligence than the LITE version, including VPNs, public proxies, Tor exits, hosting providers, and residential proxies.
Its MMDB edition exposes GeoIP2-Anonymous-IP-compatible fields:
| Field | Description |
| is_anonymous | Indicates an anonymous connection |
| is_anonymous_vpn | Indicates an anonymous VPN |
| is_hosting_provider | Indicates hosting or data center infrastructure |
| is_public_proxy | Indicates a public proxy |
| is_residential_proxy | Indicates a residential proxy |
| is_tor_exit_node | Indicates a Tor exit node |
Log in to your IP2Location account and obtain your database download token.
Run the below to download the files to your home folder after modifying for your actual token:
TOKEN="YOUR_DOWNLOAD_TOKEN"
curl -L -o DB11.zip "https://www.ip2location.com/download?token=${TOKEN}&file=DB11LITEMMDB"
curl -L -o PX10.zip "https://www.ip2location.com/download?token=${TOKEN}&file=PX10MMDB"
Extract the MMDB files:
unzip DB11.zip IP2LOCATION-LITE-DB11.MMDB
unzip PX10.zip IP2PROXY-IP-PROXYTYPE-COUNTRY-REGION-CITY-ISP-DOMAIN-USAGETYPE-ASN-LASTSEEN-THREAT-RESIDENTIAL.MMDB
Rename the PX10 file to make it shorter:
mv ~/IP2PROXY-IP-PROXYTYPE-COUNTRY-REGION-CITY-ISP-DOMAIN-USAGETYPE-ASN-LASTSEEN-THREAT-RESIDENTIAL.MMDB ~/IP2PROXY-PX10.MMDB
You should now have 2 MMDB files in your home folder like:
~/IP2LOCATION-LITE-DB11.MMDB
~/IP2PROXY-PX10.MMDB
Step 6: Store the MMDB databases #
Create a directory for the MMDB files:
sudo mkdir -p /etc/vector/mmdb
Install DB11 LITE:
sudo install -m 0644 IP2LOCATION-LITE-DB11.MMDB \
 /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB
Install PX10:
sudo install -m 0644 IP2PROXY-PX10.MMDB \
 /etc/vector/mmdb/IP2PROXY-PX10.MMDB
Set the directory permissions:
sudo chown -R root:root /etc/vector/mmdb
sudo chmod 755 /etc/vector/mmdb
Verify the files:
ls -lh /etc/vector/mmdb/
You should see both MMDB files. Vector will read them locally through its geoip enrichment tables.
Step 7: Verify the MMDB databases #
Before configuring Vector, use mmdblookup to confirm that both database files are readable.
Test IP2Location DB11 #
Run:
mmdblookup \
 --file /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB \
 --ip 8.8.8.8
The output should contain geographic information organized into fields such as country, city, location, and postal.
You can query a specific value, such as the country code:
mmdblookup \
 --file /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB \
 --ip 8.8.8.8 \
 country iso_code
The country code for 8.8.8.8 should ordinarily be US, although IP geolocation database results can change between releases.
Test IP2Proxy PX10 #
Run:
mmdblookup \
 --file /etc/vector/mmdb/IP2PROXY-PX10.MMDB \
 --ip 8.8.8.8
You can also query an individual anonymous-IP field:
mmdblookup \
 --file /etc/vector/mmdb/IP2PROXY-PX10.MMDB \
 --ip 8.8.8.8 \
 is_anonymous_vpn
For a meaningful positive proxy-detection test, use an IP address known to be classified as a proxy or VPN in your current PX10 database.
A regular public IP such as 8.8.8.8 might produce false indicators or no matching proxy record.
These tests confirm that the database files are readable and contain the expected MMDB structures. They do not yet verify Vector’s compatibility, which we will test after configuring its enrichment tables.
Step 8: Configure permissions for Vector #
The Vector service must be able to read the Nginx access log and write the enriched results to a separate output directory.
Check the service account:
id vector
On a typical Debian package installation, Vector runs under the vector user.
Debian commonly uses the adm group to control read access to system log files. Add the vector user to this group:
sudo usermod -aG adm vector
Check the Nginx log permissions:
sudo ls -l /var/log/nginx/
If the demonstration log is owned by root:adm and has group read permission, the Vector service should be able to read it after restarting.
For this dedicated demonstration log, set the expected ownership and permissions explicitly:
sudo touch /var/log/nginx/vector-demo-access.log
sudo chown www-data:adm /var/log/nginx/vector-demo-access.log
sudo chmod 640 /var/log/nginx/vector-demo-access.log
Verify access:
sudo -u vector test -r /var/log/nginx/vector-demo-access.log \
 && echo "Vector can read the Nginx log"
Next, create the output directory:
sudo mkdir -p /var/log/vector
Give Vector permission to write into it:
sudo chown vector:vector /var/log/vector
sudo chmod 750 /var/log/vector
We will use this directory to store the enriched logs.
Step 9: Configure Vector with IP2Location and IP2Proxy #
Vector supports enrichment tables that can look up information from local databases.
For this tutorial, we will use type: geoip rather than type: mmdb.
The geoip enrichment table processes recognized GeoIP database formats and produces normalized field names. For example, a city database can return country_code, city_name, latitude, and longitude.
For an Anonymous-IP-compatible database, Vector can return fields such as is_anonymous_vpn and is_tor_exit_node.
A compatibility consideration is that Vector’s geoip type is schema-aware: merely having an MMDB file does not guarantee acceptance. DB11 LITE and PX10 are intended to provide the relevant compatible schemas, but the actual files should pass Vector’s validation and lookup tests.
Create the configuration #
Open Vector’s configuration file:
sudo nano /etc/vector/vector.yaml
Replace its contents with the following configuration.
# Vector pipeline using IP2Location and IP2Proxy MMDB
# Debian 13 / Nginx access logs
data_dir: /var/lib/vector
# --------------------------------------------------
# 1. MMDB enrichment tables
# --------------------------------------------------
enrichment_tables:
ip2location:
type: geoip
path: /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB
locale: en
ip2proxy:
type: geoip
path: /etc/vector/mmdb/IP2PROXY-PX10.MMDB
# --------------------------------------------------
# 2. Read Nginx access logs
# --------------------------------------------------
sources:
nginx_access:
type: file
include:
- /var/log/nginx/vector-demo-access.log
read_from: beginning
# --------------------------------------------------
# 3. Parse Nginx logs and enrich visitor IPs
# --------------------------------------------------
transforms:
enrich_nginx:
type: remap
inputs:
- nginx_access
source: |
# Parse the standard Nginx combined log format.
parsed, parse_err = parse_nginx_log(.message, "combined")
if parse_err == null {
.nginx = parsed
.client_ip = parsed.client
# Lookup IP2Location DB11.
geo, geo_err = get_enrichment_table_record(
"ip2location",
{"ip": .client_ip}
)
if geo_err == null {
.geoip = geo
} else {
.geoip_error = "No geolocation result"
}
# Lookup IP2Proxy PX10.
proxy, proxy_err = get_enrichment_table_record(
"ip2proxy",
{"ip": .client_ip}
)
if proxy_err == null {
.proxy = proxy
} else {
.proxy_error = "No proxy result"
}
} else {
.parse_error = "Unable to parse Nginx log"
}
# --------------------------------------------------
# 4. Write enriched logs as JSON Lines
# --------------------------------------------------
sinks:
enriched_file:
type: file
inputs:
- enrich_nginx
path: /var/log/vector/nginx-enriched.jsonl
encoding:
codec: json
How the configuration works #
Enrichment tables #
The enrichment_tables section registers two MMDB files as lookup sources.
enrichment_tables:
ip2location:
type: geoip
path: /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB
locale: en
ip2proxy:
type: geoip
path: /etc/vector/mmdb/IP2PROXY-PX10.MMDB
Notice that both tables use type: geoip, as required.
Source #
The nginx_access source monitors the demonstration log file. New entries are sent to the transformation pipeline.
Transform #
The enrich_nginx transform uses Vector Remap Language (VRL).
First, parse_nginx_log() extracts the fields from a standard Nginx combined-format access log.
Next, get_enrichment_table_record() looks up the extracted client IP address in each database.
The returned records are stored under two fields:
geoip– the IP2Location DB11 lookup result.proxy– the IP2Proxy PX10 lookup result.
If a lookup fails or has no corresponding record, the event is retained with an error indicator rather than discarded.
Sink #
The file sink writes each enriched event as one JSON object per line to:
/var/log/vector/nginx-enriched.jsonl
JSON Lines is particularly useful for log processing because it is machine-readable, easy to inspect with jq, and suitable for later import into analytics platforms.
Step 10: Validate the Vector configuration #
Before starting Vector, validate the configuration:
sudo vector validate /etc/vector/vector.yaml

If the configuration and databases are accepted, Vector should report that validation succeeded.
If validation reports an unsupported database type, check the MMDB file with mmdblookup and confirm that you downloaded the correct compatible MMDB edition.
Important: Validation is especially important for PX10 because Vector’s geoip implementation interprets supported MMDB database types rather than treating every MMDB file as an arbitrary collection of fields.
If validation succeeds, start Vector:
sudo systemctl enable --now vector
Since we added Vector to the adm group, restart the service so it receives the updated group membership:
sudo systemctl restart vector
Check the service status:
sudo systemctl status vector
You should see active (running).

You can also inspect Vector’s system logs:
sudo journalctl -u vector -n 50 --no-pager
At this stage, Vector should be monitoring the Nginx demonstration log.
Step 11: Generate Nginx access logs #
Now that Vector is running, we can generate some HTTP requests.
Send several requests to the demonstration server:
curl http://127.0.0.1:8080/
curl http://127.0.0.1:8080/products
curl http://127.0.0.1:8080/contact
Nginx will generate access log entries for these requests.
View the source logs:
sudo tail -n 5 /var/log/nginx/vector-demo-access.log

Because the requests originate from localhost, the client IP will be 127.0.0.1.
This is useful for confirming that the logging pipeline works, but private and loopback addresses typically have no corresponding public geolocation or proxy intelligence.
To demonstrate real MMDB enrichment, we will simulate an Nginx access log containing a public IP address.
Step 12: Test enrichment using a public IP address #
Append a synthetic access log entry with the public IP 8.8.8.8:
sudo tee -a /var/log/nginx/vector-demo-access.log > /dev/null <<'EOF'
8.8.8.8 - - [28/Oct/2026:15:30:00 +0800] "GET /products HTTP/1.1" 200 512 "-" "Vector-MMDB-Demo/1.0"
EOF
This creates a standard Nginx combined-format log entry.
The entry is synthetic and is used only to test the processing pipeline. It does not represent an actual visitor request.
Vector should automatically detect the new line, parse it, extract 8.8.8.8, and perform both MMDB lookups.
Check the enriched output:
sudo tail -n 5 /var/log/vector/nginx-enriched.jsonl
To display the JSON in a more readable format:
sudo tail -n 1 /var/log/vector/nginx-enriched.jsonl | jq .
Example enriched output #
A successful event could resemble the following. This is an illustrative example, not actual output measured from the current databases.
{
 "client_ip": "8.8.8.8",
 "nginx": {
   "client": "8.8.8.8",
   "method": "GET",
   "path": "/products",
   "protocol": "HTTP/1.1",
   "status": 200,
   "size": 512
 },
 "geoip": {
   "country_code": "US",
   "country_name": "United States",
   "region_name": "California",
   "city_name": "Mountain View",
   "latitude": 37.4056,
   "longitude": -122.0775,
   "timezone": "America/Los_Angeles"
 },
 "proxy": {
   "is_anonymous": false,
   "is_anonymous_vpn": false,
   "is_hosting_provider": false,
   "is_public_proxy": false,
   "is_residential_proxy": false,
   "is_tor_exit_node": false
 }
}
The actual output can contain additional fields, such as the original message, source filename, hostname, timestamps, and network information.
The geolocation values depend on the DB11 LITE release. Proxy detection results depend on the current commercial PX10 data, and some addresses may not have a matching PX10 record.
View only the geolocation information #
To extract the IP and geographic information:
sudo tail -n 20 /var/log/vector/nginx-enriched.jsonl \
 | jq '{client_ip, geoip}'
View only the proxy information #
To extract the IP and proxy information:
sudo tail -n 20 /var/log/vector/nginx-enriched.jsonl \
 | jq '{client_ip, proxy}'
Identify anonymous connections #
To display enriched events flagged as anonymous:
sudo jq -c \
 'select(.proxy.is_anonymous == true)' \
 /var/log/vector/nginx-enriched.jsonl
You can also filter for specific proxy categories, such as VPN connections:
sudo jq -c \
 'select(.proxy.is_anonymous_vpn == true)' \
 /var/log/vector/nginx-enriched.jsonl
Or Tor exit nodes:
sudo jq -c \
 'select(.proxy.is_tor_exit_node == true)' \
 /var/log/vector/nginx-enriched.jsonl
These commands are useful for quickly identifying traffic patterns without setting up an additional log analysis platform.
Step 13: Verify that the log pipeline is working continuously #
Vector should automatically process new Nginx access log entries without requiring a service restart.
Open one terminal and monitor the enriched log file:
sudo tail -f /var/log/vector/nginx-enriched.jsonl
In another terminal, generate additional HTTP requests:
for i in 1 2 3 4 5; do
 curl -s http://127.0.0.1:8080/ > /dev/null
done
You should see new JSON records appearing in the output file.
The locally generated requests will contain 127.0.0.1, so geolocation lookups may not produce results. However, this confirms that Vector is continuously reading, parsing, and writing Nginx log entries.
You can stop the monitoring command with Ctrl+C.
Step 14: Updating the MMDB databases #
IP geolocation and proxy intelligence change over time. It is important to keep the MMDB databases up to date.
IP2Location LITE databases are updated periodically, while commercial IP2Proxy databases provide more frequent updates, including daily database releases.
Updating DB11 LITE #
Download the latest DB11 LITE MMDB file and install it:
sudo install -m 0644 IP2LOCATION-LITE-DB11.MMDB \
 /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB
Updating PX10 #
Download the latest commercial PX10 MMDB file and replace the existing one:
sudo install -m 0644 IP2PROXY-PX10.MMDB \
 /etc/vector/mmdb/IP2PROXY-PX10.MMDB
After replacing the files, restart Vector so that it loads the updated databases:
sudo systemctl restart vector
Check the service:
sudo systemctl status vector
For a production environment, database updates can be automated using a scheduled script. A safer update procedure downloads and validates each new database before replacing the active file, then restarts Vector and verifies that the service remains healthy.
Step 15: Troubleshooting #
The following are common issues you may encounter during installation and testing.
| Problem | Possible cause | Solution |
| Vector fails to start | Invalid YAML or MMDB incompatibility | Run vector validate and check journal logs |
| No enriched output | Vector cannot read the Nginx log | Check file permissions and Vector’s group membership |
| Geolocation fields are missing | Private IP or no matching database record | Test with a known public IP |
| Proxy fields are missing | IP is not in the proxy database, or lookup failed | Test with a known proxy IP and inspect the MMDB |
| Logs are not reprocessed | Vector has saved file checkpoints | Append new entries instead of expecting previously read lines to replay |
| Output file is missing | Incorrect sink permissions or no events | Check /var/log/vector ownership and Vector logs |
Check Vector’s error messages #
Run:
sudo journalctl -u vector -f
This displays the service logs in real time and is useful for diagnosing file access problems, invalid configurations, and database loading issues.
Verify database permissions #
Check that the Vector service account can read the MMDB files:
sudo -u vector test -r \
 /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB \
 && echo "DB11 is readable"
sudo -u vector test -r \
 /etc/vector/mmdb/IP2PROXY-PX10.MMDB \
 && echo "PX10 is readable"
Check lookup failures #
To inspect events where a geolocation or proxy lookup did not return a successful result:
sudo jq -c \
 'select(.geoip_error != null or .proxy_error != null)' \
 /var/log/vector/nginx-enriched.jsonl
A lookup failure is not always a configuration error. It can also indicate that the IP address is private, malformed, or absent from the selected database.
Check the exact MMDB database type #
If Vector reports an unsupported database type, inspect the MMDB metadata:
mmdblookup \
 --file /etc/vector/mmdb/IP2LOCATION-LITE-DB11.MMDB \
 --ip 8.8.8.8
Repeat for PX10:
mmdblookup \
 --file /etc/vector/mmdb/IP2PROXY-PX10.MMDB \
 --ip 8.8.8.8
The mmdblookup utility confirms that the file can be read as an MMDB database. Vector’s geoip type also requires a recognized database format.
If an MMDB can be opened using mmdblookup but Vector cannot load it with geoip, investigate its database metadata and supported schema before changing the pipeline.
Considerations for production deployment #
This demonstration stores enriched logs in a local JSON Lines file. The arrangement is suitable for learning and small-scale testing, but a production deployment should consider several additional factors.
Real client IP addresses: If Nginx runs behind a reverse proxy, CDN, or load balancer, its logged client address may be the upstream proxy’s IP rather than the actual visitor’s IP. Configure Nginx’s Real IP module with explicitly trusted upstream addresses before using the log data for geolocation or security analysis. Do not blindly trust client-supplied X-Forwarded-For headers.
Log rotation: The demonstration uses a dedicated Nginx log file. In production, ensure that it is covered by an appropriate log rotation policy and that Vector continues following newly created log files. A Vector file source can track file positions using checkpoints, but correct rotation handling and permissions remain important.
Database availability: A null value or lookup error should not automatically be treated as a negative proxy detection result. If there is no matching PX10 record, preserve the distinction between an unknown result and an explicit false indicator.
Log storage: Local JSON files can grow indefinitely. For production, configure retention, rotation, or forwarding to an external destination such as Elasticsearch, OpenSearch, Amazon S3, or another observability platform.
MMDB compatibility: The configuration deliberately uses geoip instead of mmdb. This approach depends on the database editions having schemas recognized by Vector. Validation and lookup testing against the actual DB11 LITE and commercial PX10 MMDB files are necessary before production deployment.
Location accuracy: IP geolocation is an estimate based on network information, not GPS positioning. It should not be treated as the precise physical location of an individual user.
Conclusion #
In this tutorial, we configured Nginx and Vector on Debian 13 to enrich web server access logs using IP2Location LITE DB11 MMDB and commercial IP2Proxy PX10 MMDB.
By using Vector’s geoip enrichment tables, we can combine local IP geolocation and anonymous-IP intelligence with ordinary Nginx access logs without making additional HTTP API requests.
The resulting JSON records provide useful information about visitors’ geographic locations and potential use of VPNs, proxies, Tor, and hosting networks.
This approach can serve as a foundation for several applications, including traffic analytics, fraud investigation, security monitoring, log analysis, and suspicious-traffic detection.
Although the demonstration stores results in a local JSON Lines file, Vector’s flexible architecture allows the same enrichment pipeline to forward processed records to a centralized logging or observability system.
For high-volume websites and security applications, combining Vector with IP2Location and IP2Proxy databases provides a practical way to add IP intelligence to existing logging infrastructure.
