From d6860c61dbe23fe41592915902ed317bf65564ae Mon Sep 17 00:00:00 2001 From: Mathieu Martin Date: Thu, 15 Nov 2018 16:24:34 -0500 Subject: [PATCH 1/6] Perform all the straightforward renames at once. - haproxy.client.port => source.port - haproxy.process_name => process.name - haproxy.pid => process.pid - haproxy.destination.ip => destination.ip - haproxy.destination.port => destination.port Add grok to conditionally extract `haproxy.client.ip` to `source.ip` (if an IP), or to `source.domain` otherwise. --- .../module/haproxy/log/ingest/pipeline.json | 24 +++++++++++++------ .../log/test/default.log-expected.json | 21 ++++++++-------- .../log/test/haproxy.log-expected.json | 17 ++++++------- .../haproxy/log/test/tcplog.log-expected.json | 9 +++---- 4 files changed, 42 insertions(+), 29 deletions(-) diff --git a/filebeat/module/haproxy/log/ingest/pipeline.json b/filebeat/module/haproxy/log/ingest/pipeline.json index b0ae63df4a8..93f959542e2 100644 --- a/filebeat/module/haproxy/log/ingest/pipeline.json +++ b/filebeat/module/haproxy/log/ingest/pipeline.json @@ -5,13 +5,13 @@ "grok": { "field": "message", "patterns": [ - "%{HAPROXY_DATE:haproxy.request_date} %{IPORHOST:haproxy.source} %{PROG:haproxy.process_name}(?:\\[%{POSINT:haproxy.pid}\\])?: %{GREEDYDATA} %{IPORHOST:haproxy.client.ip}:%{POSINT:haproxy.client.port} %{WORD} %{IPORHOST:haproxy.destination.ip}:%{POSINT:haproxy.destination.port} \\(%{WORD:haproxy.frontend_name}/%{WORD:haproxy.mode}\\)", + "%{HAPROXY_DATE:haproxy.request_date} %{IPORHOST:haproxy.source} %{PROG:process.name}(?:\\[%{POSINT:process.pid}\\])?: %{GREEDYDATA} %{IPORHOST:haproxy.client.ip}:%{POSINT:source.port} %{WORD} %{IPORHOST:destination.ip}:%{POSINT:destination.port} \\(%{WORD:haproxy.frontend_name}/%{WORD:haproxy.mode}\\)", - "(%{NOTSPACE:haproxy.process_name}\\[%{NUMBER:haproxy.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:haproxy.client.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} %{NUMBER:haproxy.http.request.time_wait_ms:int}/%{NUMBER:haproxy.total_waiting_time_ms:int}/%{NUMBER:haproxy.connection_wait_time_ms:int}/%{NUMBER:haproxy.http.request.time_wait_without_data_ms:int}/%{NUMBER:haproxy.http.request.time_active_ms:int} %{NUMBER:haproxy.http.response.status_code:int} %{NUMBER:haproxy.bytes_read:int} %{NOTSPACE:haproxy.http.request.captured_cookie} %{NOTSPACE:haproxy.http.response.captured_cookie} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:int}/%{NUMBER:haproxy.connections.frontend:int}/%{NUMBER:haproxy.connections.backend:int}/%{NUMBER:haproxy.connections.server:int}/%{NUMBER:haproxy.connections.retries:int} %{NUMBER:haproxy.server_queue:int}/%{NUMBER:haproxy.backend_queue:int} \\{%{DATA:haproxy.http.request.captured_headers}\\} \\{%{DATA:haproxy.http.response.captured_headers}\\} \"%{GREEDYDATA:haproxy.http.request.raw_request_line}\"", + "(%{NOTSPACE:process.name}\\[%{NUMBER:process.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:source.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} %{NUMBER:haproxy.http.request.time_wait_ms:int}/%{NUMBER:haproxy.total_waiting_time_ms:int}/%{NUMBER:haproxy.connection_wait_time_ms:int}/%{NUMBER:haproxy.http.request.time_wait_without_data_ms:int}/%{NUMBER:haproxy.http.request.time_active_ms:int} %{NUMBER:haproxy.http.response.status_code:int} %{NUMBER:haproxy.bytes_read:int} %{NOTSPACE:haproxy.http.request.captured_cookie} %{NOTSPACE:haproxy.http.response.captured_cookie} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:int}/%{NUMBER:haproxy.connections.frontend:int}/%{NUMBER:haproxy.connections.backend:int}/%{NUMBER:haproxy.connections.server:int}/%{NUMBER:haproxy.connections.retries:int} %{NUMBER:haproxy.server_queue:int}/%{NUMBER:haproxy.backend_queue:int} \\{%{DATA:haproxy.http.request.captured_headers}\\} \\{%{DATA:haproxy.http.response.captured_headers}\\} \"%{GREEDYDATA:haproxy.http.request.raw_request_line}\"", - "(%{NOTSPACE:haproxy.process_name}\\[%{NUMBER:haproxy.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:haproxy.client.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name}/%{NOTSPACE:haproxy.bind_name} %{GREEDYDATA:haproxy.error_message}", + "(%{NOTSPACE:process.name}\\[%{NUMBER:process.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:source.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name}/%{NOTSPACE:haproxy.bind_name} %{GREEDYDATA:haproxy.error_message}", - "%{HAPROXY_DATE} %{IPORHOST:haproxy.source} (%{NOTSPACE:haproxy.process_name}\\[%{NUMBER:haproxy.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:haproxy.client.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} %{NUMBER:haproxy.total_waiting_time_ms:int}/%{NUMBER:haproxy.connection_wait_time_ms:int}/%{NUMBER:haproxy.tcp.processing_time_ms:int} %{NUMBER:haproxy.bytes_read:int} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:int}/%{NUMBER:haproxy.connections.frontend:int}/%{NUMBER:haproxy.connections.backend:int}/%{NUMBER:haproxy.connections.server:int}/%{NUMBER:haproxy.connections.retries:int} %{NUMBER:haproxy.server_queue:int}/%{NUMBER:haproxy.backend_queue:int}" + "%{HAPROXY_DATE} %{IPORHOST:haproxy.source} (%{NOTSPACE:process.name}\\[%{NUMBER:process.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:source.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} %{NUMBER:haproxy.total_waiting_time_ms:int}/%{NUMBER:haproxy.connection_wait_time_ms:int}/%{NUMBER:haproxy.tcp.processing_time_ms:int} %{NUMBER:haproxy.bytes_read:int} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:int}/%{NUMBER:haproxy.connections.frontend:int}/%{NUMBER:haproxy.connections.backend:int}/%{NUMBER:haproxy.connections.server:int}/%{NUMBER:haproxy.connections.retries:int} %{NUMBER:haproxy.server_queue:int}/%{NUMBER:haproxy.backend_queue:int}" ], "ignore_missing": false, "pattern_definitions": { @@ -40,9 +40,19 @@ } }, { - "geoip": { + "grok": { "field": "haproxy.client.ip", - "target_field": "haproxy.geoip" + "ignore_missing": true, + "patterns": [ + "^(%{IP:source.ip}|%{HOSTNAME:source.domain})$" + ] + } + }, + { + "geoip": { + "field": "source.ip", + "target_field": "source.geo", + "ignore_missing": true } }, { @@ -68,4 +78,4 @@ } } ] -} \ No newline at end of file +} diff --git a/filebeat/module/haproxy/log/test/default.log-expected.json b/filebeat/module/haproxy/log/test/default.log-expected.json index 99a36d83793..421a3cd0fb3 100644 --- a/filebeat/module/haproxy/log/test/default.log-expected.json +++ b/filebeat/module/haproxy/log/test/default.log-expected.json @@ -1,22 +1,23 @@ [ { "@timestamp": "2018-09-20T15:42:59.000Z", + "destination.ip": "1.2.3.4", + "destination.port": "5000", "event.dataset": "log", "event.module": "haproxy", "haproxy.client.ip": "1.2.3.4", - "haproxy.client.port": "40780", - "haproxy.destination.ip": "1.2.3.4", - "haproxy.destination.port": "5000", "haproxy.frontend_name": "main", - "haproxy.geoip.continent_name": "North America", - "haproxy.geoip.country_iso_code": "US", - "haproxy.geoip.location.lat": 37.751, - "haproxy.geoip.location.lon": -97.822, "haproxy.mode": "HTTP", - "haproxy.pid": "24551", - "haproxy.process_name": "haproxy", "haproxy.source": "1.2.3.4", "input.type": "log", - "log.offset": 0 + "log.offset": 0, + "process.name": "haproxy", + "process.pid": "24551", + "source.geo.continent_name": "North America", + "source.geo.country_iso_code": "US", + "source.geo.location.lat": 37.751, + "source.geo.location.lon": -97.822, + "source.ip": "1.2.3.4", + "source.port": "40780" } ] \ No newline at end of file diff --git a/filebeat/module/haproxy/log/test/haproxy.log-expected.json b/filebeat/module/haproxy/log/test/haproxy.log-expected.json index 13c503f8b0d..e989d5f5b76 100644 --- a/filebeat/module/haproxy/log/test/haproxy.log-expected.json +++ b/filebeat/module/haproxy/log/test/haproxy.log-expected.json @@ -7,7 +7,6 @@ "haproxy.backend_queue": 0, "haproxy.bytes_read": 168, "haproxy.client.ip": "1.2.3.4", - "haproxy.client.port": 38862, "haproxy.connection_wait_time_ms": 1, "haproxy.connections.active": 6, "haproxy.connections.backend": 0, @@ -15,10 +14,6 @@ "haproxy.connections.retries": 0, "haproxy.connections.server": 0, "haproxy.frontend_name": "incoming~", - "haproxy.geoip.continent_name": "North America", - "haproxy.geoip.country_iso_code": "US", - "haproxy.geoip.location.lat": 37.751, - "haproxy.geoip.location.lon": -97.822, "haproxy.http.request.captured_cookie": "-", "haproxy.http.request.captured_headers": [ "docs.example.internal" @@ -30,13 +25,19 @@ "haproxy.http.response.captured_cookie": "-", "haproxy.http.response.captured_headers": [], "haproxy.http.response.status_code": 304, - "haproxy.pid": 32450, - "haproxy.process_name": "haproxy", "haproxy.server_name": "docs", "haproxy.server_queue": 0, "haproxy.termination_state": "----", "haproxy.total_waiting_time_ms": 0, "input.type": "log", - "log.offset": 0 + "log.offset": 0, + "process.name": "haproxy", + "process.pid": 32450, + "source.geo.continent_name": "North America", + "source.geo.country_iso_code": "US", + "source.geo.location.lat": 37.751, + "source.geo.location.lon": -97.822, + "source.ip": "1.2.3.4", + "source.port": 38862 } ] \ No newline at end of file diff --git a/filebeat/module/haproxy/log/test/tcplog.log-expected.json b/filebeat/module/haproxy/log/test/tcplog.log-expected.json index f9ef4f67ece..68ebe5798c6 100644 --- a/filebeat/module/haproxy/log/test/tcplog.log-expected.json +++ b/filebeat/module/haproxy/log/test/tcplog.log-expected.json @@ -7,7 +7,6 @@ "haproxy.backend_queue": 0, "haproxy.bytes_read": 212, "haproxy.client.ip": "127.0.0.1", - "haproxy.client.port": 40962, "haproxy.connection_wait_time_ms": -1, "haproxy.connections.active": 1, "haproxy.connections.backend": 0, @@ -15,8 +14,6 @@ "haproxy.connections.retries": 0, "haproxy.connections.server": 0, "haproxy.frontend_name": "main", - "haproxy.pid": 25457, - "haproxy.process_name": "haproxy", "haproxy.server_name": "", "haproxy.server_queue": 0, "haproxy.source": "127.0.0.1", @@ -24,6 +21,10 @@ "haproxy.termination_state": "SC", "haproxy.total_waiting_time_ms": -1, "input.type": "log", - "log.offset": 0 + "log.offset": 0, + "process.name": "haproxy", + "process.pid": 25457, + "source.ip": "127.0.0.1", + "source.port": 40962 } ] \ No newline at end of file From dd2d590d1157e834d904899c589e41273295d45b Mon Sep 17 00:00:00 2001 From: Mathieu Martin Date: Mon, 19 Nov 2018 23:01:02 -0500 Subject: [PATCH 2/6] Add a few missing integer conversions in one of the log formats --- filebeat/module/haproxy/log/ingest/pipeline.json | 2 +- filebeat/module/haproxy/log/test/default.log-expected.json | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/filebeat/module/haproxy/log/ingest/pipeline.json b/filebeat/module/haproxy/log/ingest/pipeline.json index 93f959542e2..23ac50c334c 100644 --- a/filebeat/module/haproxy/log/ingest/pipeline.json +++ b/filebeat/module/haproxy/log/ingest/pipeline.json @@ -5,7 +5,7 @@ "grok": { "field": "message", "patterns": [ - "%{HAPROXY_DATE:haproxy.request_date} %{IPORHOST:haproxy.source} %{PROG:process.name}(?:\\[%{POSINT:process.pid}\\])?: %{GREEDYDATA} %{IPORHOST:haproxy.client.ip}:%{POSINT:source.port} %{WORD} %{IPORHOST:destination.ip}:%{POSINT:destination.port} \\(%{WORD:haproxy.frontend_name}/%{WORD:haproxy.mode}\\)", + "%{HAPROXY_DATE:haproxy.request_date} %{IPORHOST:haproxy.source} %{PROG:process.name}(?:\\[%{POSINT:process.pid:int}\\])?: %{GREEDYDATA} %{IPORHOST:haproxy.client.ip}:%{POSINT:source.port:int} %{WORD} %{IPORHOST:destination.ip}:%{POSINT:destination.port:int} \\(%{WORD:haproxy.frontend_name}/%{WORD:haproxy.mode}\\)", "(%{NOTSPACE:process.name}\\[%{NUMBER:process.pid:int}\\]: )?%{IP:haproxy.client.ip}:%{NUMBER:source.port:int} \\[%{NOTSPACE:haproxy.request_date}\\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} %{NUMBER:haproxy.http.request.time_wait_ms:int}/%{NUMBER:haproxy.total_waiting_time_ms:int}/%{NUMBER:haproxy.connection_wait_time_ms:int}/%{NUMBER:haproxy.http.request.time_wait_without_data_ms:int}/%{NUMBER:haproxy.http.request.time_active_ms:int} %{NUMBER:haproxy.http.response.status_code:int} %{NUMBER:haproxy.bytes_read:int} %{NOTSPACE:haproxy.http.request.captured_cookie} %{NOTSPACE:haproxy.http.response.captured_cookie} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:int}/%{NUMBER:haproxy.connections.frontend:int}/%{NUMBER:haproxy.connections.backend:int}/%{NUMBER:haproxy.connections.server:int}/%{NUMBER:haproxy.connections.retries:int} %{NUMBER:haproxy.server_queue:int}/%{NUMBER:haproxy.backend_queue:int} \\{%{DATA:haproxy.http.request.captured_headers}\\} \\{%{DATA:haproxy.http.response.captured_headers}\\} \"%{GREEDYDATA:haproxy.http.request.raw_request_line}\"", diff --git a/filebeat/module/haproxy/log/test/default.log-expected.json b/filebeat/module/haproxy/log/test/default.log-expected.json index 421a3cd0fb3..3bbeb68f8bd 100644 --- a/filebeat/module/haproxy/log/test/default.log-expected.json +++ b/filebeat/module/haproxy/log/test/default.log-expected.json @@ -2,7 +2,7 @@ { "@timestamp": "2018-09-20T15:42:59.000Z", "destination.ip": "1.2.3.4", - "destination.port": "5000", + "destination.port": 5000, "event.dataset": "log", "event.module": "haproxy", "haproxy.client.ip": "1.2.3.4", @@ -12,12 +12,12 @@ "input.type": "log", "log.offset": 0, "process.name": "haproxy", - "process.pid": "24551", + "process.pid": 24551, "source.geo.continent_name": "North America", "source.geo.country_iso_code": "US", "source.geo.location.lat": 37.751, "source.geo.location.lon": -97.822, "source.ip": "1.2.3.4", - "source.port": "40780" + "source.port": 40780 } ] \ No newline at end of file From e8e1e0126c782304d16735a2fc5c969cccff7ab9 Mon Sep 17 00:00:00 2001 From: Mathieu Martin Date: Mon, 19 Nov 2018 23:06:43 -0500 Subject: [PATCH 3/6] Shove all renames so far in ecs-migration.yml --- dev-tools/ecs-migration.yml | 55 +++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/dev-tools/ecs-migration.yml b/dev-tools/ecs-migration.yml index cddd2a9aaf7..ca679236d9e 100644 --- a/dev-tools/ecs-migration.yml +++ b/dev-tools/ecs-migration.yml @@ -197,3 +197,58 @@ to: http.request.referrer alias: true copy_to: false + +- from: haproxy.client.port + to: source.port + alias: true + copy_to: false + +- from: haproxy.process_name + to: process.name + alias: true + copy_to: false + +- from: haproxy.pid + to: process.pid + alias: true + copy_to: false + +- from: haproxy.destination.ip + to: destination.ip + alias: true + copy_to: false + +- from: haproxy.destination.port + to: destination.port + alias: true + copy_to: false + +- from: haproxy.geoip.continent_name + to: source.geo.continent_name + alias: true + copy_to: false + +- from: haproxy.geoip.country_iso_code + to: source.geo.country_iso_code + alias: true + copy_to: false + +- from: haproxy.geoip.location + to: source.geo.location + alias: true + copy_to: false + +- from: haproxy.geoip.region_name + to: source.geo.region_name + alias: true + copy_to: false + +- from: haproxy.geoip.city_name + to: source.geo.city_name + alias: true + copy_to: false + +- from: haproxy.geoip.region_iso_code + to: source.geo.region_iso_code + alias: true + copy_to: false From b49dc4a433be5ecfd49be2af9d64f3c8edc2cf42 Mon Sep 17 00:00:00 2001 From: Mathieu Martin Date: Mon, 19 Nov 2018 23:10:11 -0500 Subject: [PATCH 4/6] Changelog --- CHANGELOG.asciidoc | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc index e0c1bd2e34b..4928526c566 100644 --- a/CHANGELOG.asciidoc +++ b/CHANGELOG.asciidoc @@ -126,6 +126,7 @@ https://github.com/elastic/beats/compare/v6.5.0...v7.0.0-alpha1[View commits] - Rename many `system.syslog.*` fields to map to ECS. {pull}9135[9135] - Rename many `iis.access.*` fields to map to ECS. {pull}9084[9084] - IIS module's user agent string is no longer encoded (`+` replaced with spaces). {pull}9084[9084] +- Rename many `haproxy.*` fields to map to ECS. {pull}9117[9117] *Metricbeat* From 3b53bdf68de24a3bc21d1be2a591774ba6057923 Mon Sep 17 00:00:00 2001 From: Mathieu Martin Date: Thu, 22 Nov 2018 14:21:17 -0500 Subject: [PATCH 5/6] Move non-normalized field defs at the top, to promote sanity. --- filebeat/docs/fields.asciidoc | 194 ++++++++++------------- filebeat/include/fields.go | 2 +- filebeat/module/haproxy/_meta/fields.yml | 123 +++++++------- 3 files changed, 152 insertions(+), 167 deletions(-) diff --git a/filebeat/docs/fields.asciidoc b/filebeat/docs/fields.asciidoc index 8362e410b34..28a302a7b5c 100644 --- a/filebeat/docs/fields.asciidoc +++ b/filebeat/docs/fields.asciidoc @@ -3393,66 +3393,6 @@ haproxy Module -[float] -== destination fields - -Destination information - - -*`haproxy.destination.port`*:: -+ --- -type: long - -Port of the destination host - --- - -*`haproxy.destination.ip`*:: -+ --- -IP of the destination host - --- - -*`haproxy.process_name`*:: -+ --- -Name of the process - --- - -*`haproxy.pid`*:: -+ --- -type: long - -PID of the process - --- - -[float] -== client fields - -Information about the client doing the request - - -*`haproxy.client.ip`*:: -+ --- -IP address of the client which initiated the TCP connection to haproxy. - --- - -*`haproxy.client.port`*:: -+ --- -type: long - -TCP port of the client which initiated the connection. - --- - *`haproxy.frontend_name`*:: + -- @@ -3562,131 +3502,173 @@ The HAProxy source of the log -- -[float] -== geoip fields +*`haproxy.termination_state`*:: ++ +-- +Condition the session was in when the session ended. -Contains GeoIP information gathered based on the client.ip field. Only present if the GeoIP Elasticsearch plugin is available and used. +-- +*`haproxy.mode`*:: ++ +-- +type: text +mode that the frontend is operating (TCP or HTTP) + +-- + +[float] +== connections fields -*`haproxy.geoip.continent_name`*:: +Contains various counts of connections active in the process. + + +*`haproxy.connections.active`*:: + -- -type: keyword +type: long -Name of the continent. +Total number of concurrent connections on the process when the session was logged. -- -*`haproxy.geoip.country_iso_code`*:: +*`haproxy.connections.frontend`*:: + -- -type: keyword +type: long -Country ISO code. +Total number of concurrent connections on the frontend when the session was logged. -- -*`haproxy.geoip.location`*:: +*`haproxy.connections.backend`*:: + -- -type: geo_point +type: long -Represents a geopoint with the longitude and latitude. +Total number of concurrent connections handled by the backend when the session was logged. -- -*`haproxy.geoip.region_name`*:: +*`haproxy.connections.server`*:: + -- -type: keyword +type: long -Name of the region +Total number of concurrent connections still active on the server when the session was logged. -- -*`haproxy.geoip.city_name`*:: +*`haproxy.connections.retries`*:: + -- -type: keyword +type: long -City name. +Number of connection retries experienced by this session when trying to connect to the server. -- -*`haproxy.geoip.region_iso_code`*:: +*`process.name`*:: + -- -type: keyword - -ISO code of the region +type: alias -- -*`haproxy.termination_state`*:: +*`process.pid`*:: + -- -Condition the session was in when the session ended. +type: alias -- [float] -== connections fields +== client fields -Contains various counts of connections active in the process. +Information about the client doing the request -*`haproxy.connections.active`*:: +*`source.ip`*:: + -- -type: long - -Total number of concurrent connections on the process when the session was logged. +type: alias -- -*`haproxy.connections.frontend`*:: +*`source.port`*:: + -- -type: long - -Total number of concurrent connections on the frontend when the session was logged. +type: alias -- -*`haproxy.connections.backend`*:: +[float] +== destination fields + +Destination information + + +*`destination.port`*:: + -- -type: long +type: alias -Total number of concurrent connections handled by the backend when the session was logged. +-- + +*`destination.ip`*:: ++ +-- +type: alias -- -*`haproxy.connections.server`*:: +[float] +== geoip fields + +Contains GeoIP information gathered based on the client.ip field. Only present if the GeoIP Elasticsearch plugin is available and used. + + + +*`source.geo.continent_name`*:: + -- -type: long +type: alias -Total number of concurrent connections still active on the server when the session was logged. +-- +*`source.geo.country_iso_code`*:: ++ -- +type: alias -*`haproxy.connections.retries`*:: +-- + +*`source.geo.location`*:: + -- -type: long +type: alias -Number of connection retries experienced by this session when trying to connect to the server. +-- +*`source.geo.region_name`*:: ++ -- +type: alias -*`haproxy.mode`*:: +-- + +*`source.geo.city_name`*:: + -- -type: text +type: alias -mode that the frontend is operating (TCP or HTTP) +-- + +*`source.geo.region_iso_code`*:: ++ +-- +type: alias -- diff --git a/filebeat/include/fields.go b/filebeat/include/fields.go index 1cb503fd21c..7290695edcf 100644 --- a/filebeat/include/fields.go +++ b/filebeat/include/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "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" + return "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" } diff --git a/filebeat/module/haproxy/_meta/fields.yml b/filebeat/module/haproxy/_meta/fields.yml index f38fecdf0ce..386e45da22c 100644 --- a/filebeat/module/haproxy/_meta/fields.yml +++ b/filebeat/module/haproxy/_meta/fields.yml @@ -2,41 +2,12 @@ title: "haproxy" description: > haproxy Module - fields: + fields: - name: haproxy type: group description: > fields: - - name: destination - description: Destination information - type: group - fields: - - name: port - description: Port of the destination host - type: long - - - name: ip - description: IP of the destination host - - - name: process_name - description: Name of the process - - - name: pid - description: PID of the process - type: long - - - name: client - description: Information about the client doing the request - type: group - fields: - - name: ip - description: IP address of the client which initiated the TCP connection to haproxy. - - - name: port - description: TCP port of the client which initiated the connection. - type: long - - name: frontend_name description: Name of the frontend (or listener) which received and processed the connection. @@ -80,40 +51,18 @@ - name: error_message description: Error message logged by HAProxy in case of error. type: text - + - name: source type: text description: The HAProxy source of the log - - - name: geoip - type: group - description: > - Contains GeoIP information gathered based on the client.ip field. - Only present if the GeoIP Elasticsearch plugin is available and - used. - fields: - - name: continent_name - type: keyword - description: Name of the continent. - - name: country_iso_code - type: keyword - description: Country ISO code. - - name: location - type: geo_point - description: Represents a geopoint with the longitude and latitude. - - name: region_name - type: keyword - description: Name of the region - - name: city_name - type: keyword - description: City name. - - name: region_iso_code - type: keyword - description: ISO code of the region - name: termination_state description: Condition the session was in when the session ended. + - name: mode + type: text + description: mode that the frontend is operating (TCP or HTTP) + - name: connections description: Contains various counts of connections active in the process. type: group @@ -137,6 +86,60 @@ - name: retries description: Number of connection retries experienced by this session when trying to connect to the server. type: long - - name: mode - type: text - description: mode that the frontend is operating (TCP or HTTP) + + + - name: process_name + type: alias + path: process.name + + - name: pid + type: alias + path: process.pid + + - name: client + description: Information about the client doing the request + type: group + fields: + - name: ip + type: alias + path: source.ip + - name: port + type: alias + path: source.port + + - name: destination + description: Destination information + type: group + fields: + - name: port + type: alias + path: destination.port + - name: ip + type: alias + path: destination.ip + + - name: geoip + type: group + description: > + Contains GeoIP information gathered based on the client.ip field. + Only present if the GeoIP Elasticsearch plugin is available and + used. + fields: + - name: continent_name + type: alias + path: source.geo.continent_name + - name: country_iso_code + type: alias + path: source.geo.country_iso_code + - name: location + type: alias + path: source.geo.location + - name: region_name + type: alias + path: source.geo.region_name + - name: city_name + type: alias + path: source.geo.city_name + - name: region_iso_code + type: alias + path: source.geo.region_iso_code From d1c9830551efed4a7d58fe70a1cf77437d4d446f Mon Sep 17 00:00:00 2001 From: Mathieu Martin Date: Thu, 22 Nov 2018 14:35:48 -0500 Subject: [PATCH 6/6] client.ip is not actually aliased. Add note that it can be a Unix socket --- filebeat/docs/fields.asciidoc | 24 ++++++++++++----------- filebeat/include/fields.go | 2 +- filebeat/module/haproxy/_meta/fields.yml | 25 +++++++++++++----------- 3 files changed, 28 insertions(+), 23 deletions(-) diff --git a/filebeat/docs/fields.asciidoc b/filebeat/docs/fields.asciidoc index 28a302a7b5c..99099d4d1e5 100644 --- a/filebeat/docs/fields.asciidoc +++ b/filebeat/docs/fields.asciidoc @@ -3569,34 +3569,36 @@ Number of connection retries experienced by this session when trying to connect -- -*`process.name`*:: +[float] +== client fields + +Information about the client doing the request + + +*`haproxy.client.ip`*:: + -- -type: alias +IP address of the client which initiated the TCP connection to haproxy. +If connection is via unix socket, socket path is in this field. + -- -*`process.pid`*:: +*`source.port`*:: + -- type: alias -- -[float] -== client fields - -Information about the client doing the request - - -*`source.ip`*:: +*`process.name`*:: + -- type: alias -- -*`source.port`*:: +*`process.pid`*:: + -- type: alias diff --git a/filebeat/include/fields.go b/filebeat/include/fields.go index 7290695edcf..11b12a4a2a9 100644 --- a/filebeat/include/fields.go +++ b/filebeat/include/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "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" + return "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" } diff --git a/filebeat/module/haproxy/_meta/fields.yml b/filebeat/module/haproxy/_meta/fields.yml index 386e45da22c..ce81845be61 100644 --- a/filebeat/module/haproxy/_meta/fields.yml +++ b/filebeat/module/haproxy/_meta/fields.yml @@ -87,26 +87,29 @@ description: Number of connection retries experienced by this session when trying to connect to the server. type: long - - - name: process_name - type: alias - path: process.name - - - name: pid - type: alias - path: process.pid - - name: client description: Information about the client doing the request type: group fields: - name: ip - type: alias - path: source.ip + description: > + IP address of the client which initiated the TCP connection to haproxy. + + If connection is via unix socket, socket path is in this field. - name: port type: alias path: source.port + + + - name: process_name + type: alias + path: process.name + + - name: pid + type: alias + path: process.pid + - name: destination description: Destination information type: group