From 0553de85b0a6ec6321558ca2a85cbece7d32cdf6 Mon Sep 17 00:00:00 2001 From: kasen Date: Fri, 7 Dec 2018 14:54:20 +0800 Subject: [PATCH 01/12] socket_summary add more tcp status --- .../system/socket_summary/_meta/fields.yml | 13 ++++++++ .../system/socket_summary/socket_summary.go | 31 ++++++++++++++----- 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml index 65b78d46907f..1b0cfc44b32c 100644 --- a/metricbeat/module/system/socket_summary/_meta/fields.yml +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -35,6 +35,18 @@ type: integer description: > All TCP listening ports + - name: established + type: integer + description: > + TCP established ports + - name: close_wait + type: integer + description: > + TCP close_wait ports + - name: time_wait + type: integer + description: > + TCP time_wait ports - name: udp type: group description: > @@ -51,3 +63,4 @@ All open TCP connections + diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go index ede26e2279ba..ca79d3cecfe8 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -64,11 +64,14 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) { func calculateConnStats(conns []net.ConnectionStat) common.MapStr { var ( - allConns = len(conns) - allListening = 0 - tcpConns = 0 - tcpListening = 0 - udpConns = 0 + allConns = len(conns) + allListening = 0 + tcpConns = 0 + tcpListening = 0 + tcpClosewait = 0 + tcpEstablished = 0 + tcpTimewait = 0 + udpConns = 0 ) for _, conn := range conns { @@ -78,7 +81,15 @@ func calculateConnStats(conns []net.ConnectionStat) common.MapStr { switch conn.Type { case syscall.SOCK_STREAM: tcpConns++ - + if conn.Status == "ESTABLISHED" { + tcpEstablished++ + } + if conn.Status == "CLOSE_WAIT" { + tcpClosewait++ + } + if conn.Status == "TIME_WAIT" { + tcpTimewait++ + } if conn.Status == "LISTEN" { tcpListening++ } @@ -94,8 +105,11 @@ func calculateConnStats(conns []net.ConnectionStat) common.MapStr { }, "tcp": common.MapStr{ "all": common.MapStr{ - "count": tcpConns, - "listening": tcpListening, + "count": tcpConns, + "listening": tcpListening, + "established": tcpEstablished, + "close_wait": tcpClosewait, + "time_wait": tcpTimewait, }, }, "udp": common.MapStr{ @@ -123,3 +137,4 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) { MetricSetFields: calculateConnStats(conns), }) } + From 12393a3a16ea1ed5dd150d97dd2dfcdef9b45872 Mon Sep 17 00:00:00 2001 From: kasen Date: Fri, 7 Dec 2018 15:46:51 +0800 Subject: [PATCH 02/12] fix socket summary for add tcp status --- metricbeat/module/system/socket_summary/socket_summary.go | 1 - 1 file changed, 1 deletion(-) diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go index ca79d3cecfe8..d9a7943545b4 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -137,4 +137,3 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) { MetricSetFields: calculateConnStats(conns), }) } - From 274a6317f04e7bc790f3f4a26f1d84187bfd29cc Mon Sep 17 00:00:00 2001 From: kasen Date: Fri, 7 Dec 2018 16:02:38 +0800 Subject: [PATCH 03/12] fix socket_summary add more tcp status --- metricbeat/module/system/fields.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 0f8a61053cb8..13e64af0dd91 100644 --- a/metricbeat/module/system/fields.go +++ b/metricbeat/module/system/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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" } From aa6e21452fe602078974be012fb61228574e49b5 Mon Sep 17 00:00:00 2001 From: kasen Date: Fri, 7 Dec 2018 16:24:29 +0800 Subject: [PATCH 04/12] socket_summary update field doc --- metricbeat/docs/fields.asciidoc | 42 ++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 6 deletions(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 1c04a31a5cbc..589722530a80 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -18367,7 +18367,7 @@ type: long format: bytes -Used memory by the Lua engine. +Used memory by the Lua engine. -- @@ -18379,7 +18379,7 @@ type: long format: bytes -The size in bytes of the dataset +The size in bytes of the dataset -- @@ -18624,7 +18624,7 @@ type: long format: bytes -The size in bytes of copy-on-write allocations during the last RBD save operation +The size in bytes of copy-on-write allocations during the last RBD save operation -- @@ -18753,7 +18753,7 @@ type: long format: bytes -AOF current file size +AOF current file size -- @@ -18857,7 +18857,7 @@ Total size in bytes of the replication backlog buffer -- type: long -The master offset of the replication backlog buffer +The master offset of the replication backlog buffer -- @@ -22073,6 +22073,26 @@ type: integer All open TCP connections +-- + +*`system.socket.summary.tcp.all.close_wait`*:: ++ +-- +type: integer + +TCP close_wait ports + + +-- + +*`system.socket.summary.tcp.all.established`*:: ++ +-- +type: integer + +TCP established ports + + -- *`system.socket.summary.tcp.all.listening`*:: @@ -22080,7 +22100,17 @@ All open TCP connections -- type: integer -All TCP listening ports +TCP listening ports + + +-- + +*`system.socket.summary.tcp.all.time_wait`*:: ++ +-- +type: integer + +TCP time_wait ports -- From 037e45f566228976f65b8b6352734f6aa921696e Mon Sep 17 00:00:00 2001 From: kasen Date: Sat, 8 Dec 2018 13:00:10 +0800 Subject: [PATCH 05/12] fix socket_summary fields --- metricbeat/docs/fields.asciidoc | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 589722530a80..6e7829bda056 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -18367,7 +18367,7 @@ type: long format: bytes -Used memory by the Lua engine. +Used memory by the Lua engine. -- @@ -18379,7 +18379,7 @@ type: long format: bytes -The size in bytes of the dataset +The size in bytes of the dataset -- @@ -18624,7 +18624,7 @@ type: long format: bytes -The size in bytes of copy-on-write allocations during the last RBD save operation +The size in bytes of copy-on-write allocations during the last RBD save operation -- @@ -18753,7 +18753,7 @@ type: long format: bytes -AOF current file size +AOF current file size -- @@ -18857,7 +18857,7 @@ Total size in bytes of the replication backlog buffer -- type: long -The master offset of the replication backlog buffer +The master offset of the replication backlog buffer -- @@ -22075,12 +22075,12 @@ All open TCP connections -- -*`system.socket.summary.tcp.all.close_wait`*:: +*`system.socket.summary.tcp.all.listening`*:: + -- type: integer -TCP close_wait ports +All TCP listening ports -- @@ -22095,12 +22095,12 @@ TCP established ports -- -*`system.socket.summary.tcp.all.listening`*:: +*`system.socket.summary.tcp.all.close_wait`*:: + -- type: integer -TCP listening ports +TCP close_wait ports -- From 9098c631372c29031d8ef2fcc97ab19be59172a8 Mon Sep 17 00:00:00 2001 From: yaule Date: Fri, 14 Dec 2018 11:10:25 +0800 Subject: [PATCH 06/12] add socket summary test --- .../socket_summary/socket_summary_test.go | 177 +++++++++++------- 1 file changed, 109 insertions(+), 68 deletions(-) diff --git a/metricbeat/module/system/socket_summary/socket_summary_test.go b/metricbeat/module/system/socket_summary/socket_summary_test.go index 22f97df283eb..47cec242929c 100644 --- a/metricbeat/module/system/socket_summary/socket_summary_test.go +++ b/metricbeat/module/system/socket_summary/socket_summary_test.go @@ -18,90 +18,131 @@ package socket_summary import ( - "syscall" - "testing" + "syscall" + "testing" - "github.com/shirou/gopsutil/net" - "github.com/stretchr/testify/assert" + "github.com/shirou/gopsutil/net" + "github.com/stretchr/testify/assert" ) func getMockedConns() []net.ConnectionStat { - return []net.ConnectionStat{ - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_DGRAM, - Status: "", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_DGRAM, - Status: "", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "LISTEN", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "ESTABLISHED", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "ESTABLISHED", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "CLOSE", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "LISTEN", - }, - } + return []net.ConnectionStat{ + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_DGRAM, + Status: "", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_DGRAM, + Status: "", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "LISTEN", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "ESTABLISHED", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "ESTABLISHED", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "TIME_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "LISTEN", + }, + } } func TestCalculateConnStats(t *testing.T) { - conns := getMockedConns() - metrics := calculateConnStats(conns) + conns := getMockedConns() + metrics := calculateConnStats(conns) - allConns, err := metrics.GetValue("all.count") + allConns, err := metrics.GetValue("all.count") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - allListens, err := metrics.GetValue("all.listening") + allListens, err := metrics.GetValue("all.listening") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - udpConns, err := metrics.GetValue("udp.all.count") + udpConns, err := metrics.GetValue("udp.all.count") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpConns, err := metrics.GetValue("tcp.all.count") + tcpConns, err := metrics.GetValue("tcp.all.count") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpListens, err := metrics.GetValue("tcp.all.listening") + tcpListens, err := metrics.GetValue("tcp.all.listening") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - assert.Equal(t, allConns, 7) - assert.Equal(t, allListens, 2) - assert.Equal(t, udpConns, 2) - assert.Equal(t, tcpConns, 5) - assert.Equal(t, tcpListens, 2) + tcpEstablisheds, err := metrics.GetValue("tcp.all.established") + + if err != nil { + t.Fail() + } + + tcpClosewaits, err := metrics.GetValue("tcp.all.close_wait") + + if err != nil { + t.Fail() + } + + tcpTimewaits, err := metrics.GetValue("tcp.all.time_wait") + + if err != nil { + t.Fail() + } + + assert.Equal(t, allConns, 13) + assert.Equal(t, allListens, 2) + assert.Equal(t, udpConns, 2) + assert.Equal(t, tcpConns, 11) + assert.Equal(t, tcpListens, 2) + assert.Equal(t, tcpEstablisheds, 2) + assert.Equal(t, tcpClosewaits, 3) + assert.Equal(t, tcpTimewaits, 1) } From 04e78535e8df11c615e67655c2afb97529d43beb Mon Sep 17 00:00:00 2001 From: kasen Date: Thu, 13 Dec 2018 18:22:33 -0900 Subject: [PATCH 07/12] fix socket summary fmt --- .../socket_summary/socket_summary_test.go | 206 +++++++++--------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/metricbeat/module/system/socket_summary/socket_summary_test.go b/metricbeat/module/system/socket_summary/socket_summary_test.go index 47cec242929c..d542e551aee8 100644 --- a/metricbeat/module/system/socket_summary/socket_summary_test.go +++ b/metricbeat/module/system/socket_summary/socket_summary_test.go @@ -18,131 +18,131 @@ package socket_summary import ( - "syscall" - "testing" + "syscall" + "testing" - "github.com/shirou/gopsutil/net" - "github.com/stretchr/testify/assert" + "github.com/shirou/gopsutil/net" + "github.com/stretchr/testify/assert" ) func getMockedConns() []net.ConnectionStat { - return []net.ConnectionStat{ - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_DGRAM, - Status: "", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_DGRAM, - Status: "", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "LISTEN", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "ESTABLISHED", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "ESTABLISHED", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "CLOSE_WAIT", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "TIME_WAIT", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "CLOSE_WAIT", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "CLOSE_WAIT", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "CLOSE", - }, - net.ConnectionStat{ - Family: syscall.AF_INET, - Type: syscall.SOCK_STREAM, - Status: "LISTEN", - }, - } + return []net.ConnectionStat{ + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_DGRAM, + Status: "", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_DGRAM, + Status: "", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "LISTEN", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "ESTABLISHED", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "ESTABLISHED", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "TIME_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE_WAIT", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "CLOSE", + }, + net.ConnectionStat{ + Family: syscall.AF_INET, + Type: syscall.SOCK_STREAM, + Status: "LISTEN", + }, + } } func TestCalculateConnStats(t *testing.T) { - conns := getMockedConns() - metrics := calculateConnStats(conns) + conns := getMockedConns() + metrics := calculateConnStats(conns) - allConns, err := metrics.GetValue("all.count") + allConns, err := metrics.GetValue("all.count") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - allListens, err := metrics.GetValue("all.listening") + allListens, err := metrics.GetValue("all.listening") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - udpConns, err := metrics.GetValue("udp.all.count") + udpConns, err := metrics.GetValue("udp.all.count") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpConns, err := metrics.GetValue("tcp.all.count") + tcpConns, err := metrics.GetValue("tcp.all.count") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpListens, err := metrics.GetValue("tcp.all.listening") + tcpListens, err := metrics.GetValue("tcp.all.listening") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpEstablisheds, err := metrics.GetValue("tcp.all.established") + tcpEstablisheds, err := metrics.GetValue("tcp.all.established") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpClosewaits, err := metrics.GetValue("tcp.all.close_wait") + tcpClosewaits, err := metrics.GetValue("tcp.all.close_wait") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - tcpTimewaits, err := metrics.GetValue("tcp.all.time_wait") + tcpTimewaits, err := metrics.GetValue("tcp.all.time_wait") - if err != nil { - t.Fail() - } + if err != nil { + t.Fail() + } - assert.Equal(t, allConns, 13) - assert.Equal(t, allListens, 2) - assert.Equal(t, udpConns, 2) - assert.Equal(t, tcpConns, 11) - assert.Equal(t, tcpListens, 2) - assert.Equal(t, tcpEstablisheds, 2) - assert.Equal(t, tcpClosewaits, 3) - assert.Equal(t, tcpTimewaits, 1) + assert.Equal(t, allConns, 13) + assert.Equal(t, allListens, 2) + assert.Equal(t, udpConns, 2) + assert.Equal(t, tcpConns, 11) + assert.Equal(t, tcpListens, 2) + assert.Equal(t, tcpEstablisheds, 2) + assert.Equal(t, tcpClosewaits, 3) + assert.Equal(t, tcpTimewaits, 1) } From 88d1f316abef9a6a992d74f32baf36ad7e3c6e96 Mon Sep 17 00:00:00 2001 From: kasen Date: Thu, 13 Dec 2018 21:02:55 -0900 Subject: [PATCH 08/12] fix socket summary test --- .../module/system/socket_summary/socket_summary_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/metricbeat/module/system/socket_summary/socket_summary_test.go b/metricbeat/module/system/socket_summary/socket_summary_test.go index d542e551aee8..bcd3f4d88c1e 100644 --- a/metricbeat/module/system/socket_summary/socket_summary_test.go +++ b/metricbeat/module/system/socket_summary/socket_summary_test.go @@ -137,10 +137,10 @@ func TestCalculateConnStats(t *testing.T) { t.Fail() } - assert.Equal(t, allConns, 13) + assert.Equal(t, allConns, 11) assert.Equal(t, allListens, 2) assert.Equal(t, udpConns, 2) - assert.Equal(t, tcpConns, 11) + assert.Equal(t, tcpConns, 9) assert.Equal(t, tcpListens, 2) assert.Equal(t, tcpEstablisheds, 2) assert.Equal(t, tcpClosewaits, 3) From 192c0998049e9defa1d1d90ffe4c25244c282362 Mon Sep 17 00:00:00 2001 From: kasen Date: Fri, 14 Dec 2018 15:48:45 +0800 Subject: [PATCH 09/12] fix socket summary test --- metricbeat/tests/system/test_system.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/metricbeat/tests/system/test_system.py b/metricbeat/tests/system/test_system.py index 7984d1b105d3..10569461b856 100644 --- a/metricbeat/tests/system/test_system.py +++ b/metricbeat/tests/system/test_system.py @@ -480,6 +480,9 @@ def test_socket_summary(self): assert isinstance(tcp["all"]["count"], int) assert isinstance(tcp["all"]["listening"], int) + assert isinstance(tcp["all"]["established"], int) + assert isinstance(tcp["all"]["close_wait"], int) + assert isinstance(tcp["all"]["time_wait"], int) assert isinstance(udp["all"]["count"], int) From 5f42c0c84d2e7732edda2b7ea3e5ccd4aa6dcecd Mon Sep 17 00:00:00 2001 From: Jaime Soriano Pastor Date: Fri, 14 Dec 2018 22:07:27 +0800 Subject: [PATCH 10/12] Apply suggestions from code review Co-Authored-By: yaule --- metricbeat/module/system/socket_summary/_meta/fields.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml index 1b0cfc44b32c..354fb6193560 100644 --- a/metricbeat/module/system/socket_summary/_meta/fields.yml +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -38,15 +38,15 @@ - name: established type: integer description: > - TCP established ports + Number of established TCP connections - name: close_wait type: integer description: > - TCP close_wait ports + Number of TCP connections in _close_wait_ state - name: time_wait type: integer description: > - TCP time_wait ports + Number of TCP connections in _time_wait_ state - name: udp type: group description: > From 00ecfbdde520aaf9bfc1abb84779b59261b1a493 Mon Sep 17 00:00:00 2001 From: kasen Date: Thu, 13 Dec 2018 23:33:09 -0900 Subject: [PATCH 11/12] update asset data --- metricbeat/module/system/fields.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 13e64af0dd91..ab8328a3d878 100644 --- a/metricbeat/module/system/fields.go +++ b/metricbeat/module/system/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "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" + return "eJzsXeuPGzeS/+6/ojCHhcd3M7LHm2Rz8+EAJ97gBkjigR/YBe4OMtVdkrjDJjskW7Ly1x/46Ddb6pZaDweZD9n1jFT8VbFYrCoWi7fwhJt7UBulMXkGoKlmeA9XH+wvrp4BxKgiSVNNBb+H/3oGAOD+CEoTnSlIUEsaqRtg9Anhx8dPQHgMCSZCbiBTZIE3oJdEA5EIkWAMI40xzKVIQC8RRIqSaMoXHsXkGYBaCqmnkeBzurgHLTN8BiCRIVF4DwvyDGBOkcXq3gK6BU4SrLBhfvQmNZ+VIkv9bwKsmJ/P7mufIRJcE8oVMBER5qnl/E3856vjVseOhMTil6HRtyCooLg1dCpQjDw9ApgLCQQU5QuGdjwQcyCQZExT+72KBPOfutDynyYTVUZoXPt1zgoTfNH4wxZuzI+B/qNBxbNkhrJEVfvkv8Ejygi5JgtUQUCZQjlJIx2EpSLCMJ7OmSDND8yFTIi+h9TRHwb+4xLzL5KFFbRhR9MEQaXINVBugYFKSYQdvNU40DR6UuOI1oAjici4PhCY15dLFO4TSo5sCBcjCninhAeg4zTCy5Ow4MDE+jaVVEiqN5BKEaFSqPpwczJJ74uSxuwCZW5R9QB+OkXuAUisCdUXKEsOBhhcCw4xVU8v+vFxShsxDJ/87fKErFCuaGRcM+PSLQmPmfnHksh4bbw5yjVKmaV653qUv51O9KOhVmKuv6Z5MXj34/Dcc7MHco2EXd7MUA6UrwTLuCZy40zAbGPjnBWVOiPMfmO9pAztb5eb1IhECdkabE1UTV5CL1HmW6CQk9YX3qwIZWTGEARnG7N5fuL0Sy9BntIuXq6AilguzQ4K5aI0a0WThisTMavDojMT5o05US42yyfKUodUovLel50BofTEfVjwW27WD6O/YzNMhMrKULCmjMGSrNAEqOQLTbIEVoRldtF8vnv16i/w7264z5Z2i1g5To0uYRJJvAFNnox+UOWpUq4FkCiyaudsy6pNNIDFQPlDh6bwjrdTBOqmRXYjMogId5NWFXmRvFlIJBql+QV3coOfhAT8QpKU4Q3QOfy1RdaplPk60fDdq78YaDdGr5xy+bTHJEqzSS7Nz057Zgh333dOzh8rhP1jBYlfb/j1R4l2viKv9U+/PMDhn97tON6tFvpCBWl8QVTg2LY76kPM0CrOw7t/GCvU5ZT8WnpGvfwT40ldpAiGpqkvlpGhG/1lMnLQbn+ZLPXf8i8U/x77/mVyMvrm/1Wxua8HcJlMfq1uwKVJs48XcJMnQhTGuZDLnI0NrgO8NzyGj63s3tdyMn3JZ7pfxynoBR4mXvQh3LmPQvbfEc+NfN9N7s+zh6pMjJ5S8awpiiHHD4ZE5fzB/BMe3hVlZD1r8PKf4WcU5r/B+XzCzVrI5sGBzx/fg4rJ3fDptuyZIXcpG0pK2NRtngPg9YTwXPkR8nI3+LikChKyAS40zNAox4rGbhsnjJVCb9H0OfodDEkk8cQeeIy4eKynVPEwzCBGZcwMGZVRWWQ0fJ4xttmBby2pxqMDtKPsidBKcLbR/U/Uclcw9KU9wFsyFkYdNrzj8DPl2Rd3xEWbQ0HDD1QYaSE9JXvYkzLqNY0DUSpLjGTsp0DR360f+u3d614zeH4BGRwa+Tgyyon1FFOL6m6xWbUy+84R1T6hzMQEkeCx8tubNyt2xfaa2LNBdGt2p7N4bIBhjLEw++DDy3e7AZrobWJnW+JvGSo9SVAuUE1TlFOFURB7KMLcAb55VG+XuR9SgR3TnpKD48Sd2K5RIvyWYYYxaGEXQ4wrujO28Ww5FTktX3bMYzNWm6+TTlSJnirVQl/hc48JOu3MjMuJnRHPwJbdZgQ2fij328L3bWFu+u7hLW0nQ8TEF+MyQlYoyQKrMc1cyIaWBWdEC+OBmoAF4yHr/4Sz4lTsmNPiWDrdvDQWzUgTk694slpMjY9yHFas93NNee42vTATZXD3tAH9eLFW/Mic2DGAIV/o5VGYOOVCH1eVXAIDp51+1uFq5EZwjBh1qjpcLyxTDy/fjTsfs0xtxuPmMZy7jzNp3MT1kkbLOgvd2+L1jPB4TWO9hExTRn8nZlgrhPJTLybw1n1cEZ1J9xERRZkJXVzVXFn0qCBiQtmpr9cx5iKZU4a1W5GwV0apJNOqay3/NEZ5K8mzZCeKN23yyGb8y6GNNAmHjKeSrihD44PacwvK3TCTIHQ3fdOBya9BCa5queU9fH4Z4+ql+evd5yAiM+4RoBgaTSj4RX8TBmGTsdNU0I4s0N5YLGGzBi3tlmzCaKy2HjGkNPSBixiV0Razqu1v2lnVCiSJZ9X27Vpt0E3HllpFXhJxH6FZuZ80J1WR3XaJZQpPm1Q0Aw6Ed/5D8AbobWfYhSoqs8EctI95lXKUKltZZRPLT0nIYiFxQYpjEsKYMzmNiw/lVw++2bFvovzXuvnxaGAusmbUVFs+ByzrjwGz16FvbqiAe79N68Mz22YclZ2fkmuIRaRakWJA6rDdAm8VxS70LZwhvxK8EK0FbKyBJkCzWM4G0K7UHQBD5vh0CJ3Zu7ZAU5YpK9MXbWeYCRIfYj6M829o5NHNgQv+6u5qqBE2f6J8MZ0TE5TfG6d/mCH+uQK/CDwYURoSyjON4TV89e0lIf3WY+0wOFd3F4X2LgA3jNuWp51LJwK6ADEtzqv7lZ212TnXVIQVZgyOzqZdHVp1IE/2Q2GOjnuhtGWdXceog9w7R6KVovC9qEZIT5ws7LD7msO9u7fQ6cKNT2aL7QXrhFGti8/Kqi/rUfk5L2IhV43j0maxQGWLciiPWBYXH44EdxUAs03uTkYkWqICwtv+1yybz1EquFZYxKpeNCTSGWGThhty8eFYr4l1vO3nr7eRvLHUym5xGNuaQiO5XV78Vm85uCLgBB6pZ6giz4oOPmiQ6I2hcjlfapQIeYQwQ71Gfyvaq7Q98a7mavwMBS/Mm5/mJyHGFHmscsv77oPLkyVCIsSoCWXqBlJrBiFaYvRUxMgVHf7coRJw/hjKizu85B+0zZATFmXMBvIzYqalIouihIhqu/qp0io/I6rQDA5tI43SPuT2wBJ99+GfhiRVQEBlSdMq5RNLOYk0XZXz+o7DPyiPxVrd+O/jb+3V5kUrirnyX+87Vx02B/rYHdhpe3rOXNsGkdbS2VXRuSZNc9NtiFKJc/rlHq7+x7L1f02fp57fMJuFpVL6EsZ9oErTSBnHweqTP94xOGoNL3MVC2Uwd6cjzhxMl8z0VaVz2VrrjQzDey4zVdjlPcR7eSs16yf4nItltsC0dUf5DIvVAAGL5OzrNFiG3mItPCFlvrfCkD85SYVgl75uf6l4e5QDYSZMM1NUsjPG2tjBwEFrol4VUNOrzuILGMkOjaM6pau4txIZR1au9k9Nj8NIjgJmmbZRXUifBnKmMmncu/MyJlYoI5EkdPDSiHFOMqZDpy69eThgfb91w7sasrmQQfDFZSHUayGfnjXhDcn7eBqVxI//TfXaU617dv53e1Vt3jjbON2NJ9TLgalAm2Jrgu9z/Ulk+qSn0s07HCbm3VW/xc+KUGKEdHftnBFkSqIn1McpifC0ewrseEhkgaSnYCifoJRCHkcsjrS/nOkQUb7oMVenwqSQx7sRUT6JpUjT1q45DiLKI5HYoig/d2VBpR+2h8SOCVBkeiG2A6ymaqkCwtZk096JXhnn/S2Ra+NB8hh++PAWZhiRTKFPnRhfQGIqpC5PR7ovuuYC8Fd4D9qPPI3KfuR/YzYjEhNNbqoPO9xUX8xoPDcBp9iP+qSLPQP1nQZql7mJPtKglnSjwu9KZpxTvrgKo0lHe8aiCiSlHQU16ZHGIxK53jLs4ijDumC6a9AoiRnlI0/1PGMMjLdLeHxryLvwUAsz+VI7593Bu/HnNmYV60AinMhFltgMu8KUSOKXf7CEhS64kDglM7HCe3j96pvvgyxnCuX4ayqnmmecbZGxtYeR7bQaV7mewEP5qQAWgIhwf9M8Ro0yoRzjG19OiSx2TVW9RSooPW9bVp4lKGkENEau6ZyihOtPD29f1NPTtgzdEfbHaGob0VgkxFtqqrznZjgkCj67v/1vztjnDrVbh1V9b/FHmbSry/jSRpdiKu1dl00+H4XkP1Z4VbZ/Q1vpKu0d3JlCmAvkqyAXYvYvbOUy3C+nB/KJfEWl4GZJwIpIalCq7uXlWj2bTSp0p7rG508S8YcPb28cw24be/cB/tkxgbWu2jBeAvDHx0+3KsWIzmlUzfylZUeOobm9zr5IsCt+7plQDTQp0dUdb1vDpCZY193KOkxHQlt0yzZgXepUUR6h0x5viLtkvbsbJ5w5n93oE+N9xWIuLKdF6U2WxtYbedAVJ1XRhDIi/YlQcNi/mFEKQVYHiKlKGdmUXqoWab4X5o1i2j1BwsLt6HH2VUkYV7XQt065GhpUesS3qp/K6iO752iQhLePIDzTUiTwqn2LqiniLU3J4MR2IdysrAnY6cQx8bpKha3Tu0WexnqEbh+W6OJ2UDEEncG0znvN50K0vZvM0Njh4QZP/XvWuLjDjaH70a79btd+daZMb6kBeQMtH8VWxb0kW1RAKnW2cyiD/j0q6+fCB9Twgf6Ok8YyDDAkoihLqTu8sl6t/8z1+ze/vNjO6uVZ5vH4U0siz6WEduw4xEymOq+2heOJParYfqIMi88I6T2kPJPjNi2FXp3caQRVFVd6Hmgw5+qSzN7lveyxTYZIkR+0KTRu8tVloCz93jsBownVEyXmg49z+yqImGs3Sn7ovwN64VMESdZipQrtiHATgEdL42zETT+HaCB8Y3elXaJYklaoN5YoDOljiaJC24jCtjqcIUiS96+VQuiO8DC08PZekr/k1/i4x6PK1iJuJNvWxl7fty43UU+uXi/B+mu1+Y//VnE/UGKZXW65GEuiPCG1pKmtcmjnWQS/NeLwlK0AFdYGsPLblVrYvdRbSULYkT3pIWDw2vTw1oYqRpOEvSTpuFFAlBIRtWmsNdVLlzAyYg579i67ZVsn8OcaSE714a1LVfjWYTn1SvrJPxYUpEpmW47RqiJKiV4eT0iGel4t6PXIliXRFTZ+rbKZizKeK3fd1N1uHyQyO9ophNbO6MDWNTtAYlGalbIAFS0xzhi697CJ7QLoLsQQ9VQUd/h1FKT5xn0nt8+CaykY85ZtLYpUcTGUVDfw408frAF5/zFM1PxdacJjBybvQck2MCdUlqS8nUmlMPaCCk5YIIVopWMv87hMahFU5ZXh+TQWZcxrpIulnsD7jxUYQboSCfMRWgOUQq0q76IF48+gPwplH+r6BFgh+7sUeZ8UAgu6Qm58Tyq2FUh1GzPYZdCgx3qFpgY+vM2zMU3t2Qqgw1zsBSG8CMzP4z5mo5NayJxsZTKaq4mfsGAtFOxySIawasexc+Fb4yc0kiJvzWiriMQaJC4yRqTZFTtJOZE8V7md0MLqskQlMhmhArUUGYutX4JFsdgAmfyWCU2OL5KPjXtNnYJxC5mw8D0BCyk3k6S6RmXG8/UpOPq1CddEQYxz6ty+bilXlaPrllNIejZUO7bs3nBbHbVA6bOF9ljNJ2XQGLxiIVk8VYPXSbTWISh3GmtinVSy5flgsbeO3ZJMMy8U534nmbKneK/BKD1dLKve6FbxSn3B67VYl93y7VivVO2xUKWeyIzbUOsShGGT24IvUNmbRpryTGTKr7lOwpQ3QpT6Inbvq4al1lNM7lKsg3FsMZWlrd7U2ALGFWHKGp3agjGLom5iuo2bWdpWFMhIur3+us26XkqhNcP45EIwuqK6ZnXmrgJ6bHBtmaSBZ1vzn7zyee2OdY1tz8uh9BI3XkBfliSzPVNsA/r5VrtUMXdGq2sz5PIBVILdC/ua/6bE+dG30CI/nTftc/30rikHTrioNSL0K62Yjx0ORmie+sVMJNqSBe4VN/koKO+AFqgZy3/+9KaLnzN70/589jReY/WNqYqi1664GxNQjZ936PugNe4enhyH14KXKvgCuC2QSETcVf8expe/KHkyhNfuwPbFEKgpynCGBbaXDeU/tfKhwzWr4LJlPQu2BQck0dJ+tKFhW7Zvqnar2NajWRhmPf39M58WdrW3fxrQIxnQ4YYywWRiT9A6D4ahzwrddbI4gPFqOxZ/uDfbdKa/rvMOBH3dopLhhHy5HKaXWGQFq/05xubcnXddItdl6sVtMvX+EobbvAzZxO3d2yeJlvjChSmBfLU96Kl47pnquz8Y6c0JZdnx8yn1s14fuViGlkVXC3fsd92Y0xewJt1elDTbRe+ILcFErS/NNiwxb/GRFxTXDIVtE2Lvyrs2hX4NddIbc20VwrpUu9IqszGbcVtYNaFscSQOFdbFm6I8k+QVrik0O9nb8yRjGyC1viQT1FxsdkI7KV63Zt0aq4FG6elS/RVfIno0t+Xp8v2Wpgh2ui+dVIdL5uKNiZg35LPNQHRnCfcxHE+X6bo0521M38XQnuoovUhTUbMRZpP5+ONj0eCw3U9+CKOXahqqNqHJccBG7EiO7Wc9rZi+BjvhhdWUU8tg7JLS3p5GIa3LNBrNiew+rBruX7iEpWsUOCVchJtk9BbAiLryhgu+SUSmSg/UxrogOPjGhgyJ0rcSI+SabW7tarv++f2nbgExqnTthm+SzhVcq2WCyYubocaoJjwTpZ9YeD9RhrczEj2VxemlcH5+/6lgdw+urKxPzM+j2SDswGPP0ZKiJDJa0oiwqRPV9LJMYzVtXERiOWzvPRUNHyp2wtm+7pPbUcSl1pcprTIi6y23TpJ1ee4nt7zl6tdjSYsmsVVzUVt53QFuc0XuJakzmM1uSYUNalBGe2hHQtIU48vi+IN/rt1xe+sggv8f+/BOtyke1+akZIFT29rt5EUyxkaQ4nZFPTrVki4WKDE2n9iWALPQB+rDv4ScfgV8W6A7GIerX8ynrtw/FSyNCvHy7opPBrg2zGxj77BosS38dQ1KbKsIe7kmptXbHT01Sk070y5HKDyzzSDNf231mah0VKfuUp57h6t3yWWVD5F15RqPy4jIKkHaoaxsu5Dbi5VTbIvXZcsZSbjybZKKPsMvboCL7rzvuI6rVGpqRr4Yqf3a6Gso5kAKQQblNax0Zk3Si+H1Q3HssefsZRxXNNJkdkE7/i+VdGzZ1ElixAhNMO7Fac7ljD3RkA0fUC7zAxNRtZPqn1UyY1fJ7FEk46oJL0Vjm+9BOsNjbc0cpXTZPvewi39Kc2aVyr2Z3B3AdB/WDBITFaepuiwF8PDyXd5rUnBb5m+k7SrkDPv7M27rsLG8Wu9rj91DyIxGm86WlhOVJQmpP7FFNcN7ePT+5Yf2B4b2vvQkal2XKxejUYHv2xh+DOzoj3L1enir0oy3gC38y+tNvJUbJ46xkZBUGpx7gQ3BQuP+T6j3BmKIDkKhGGJ6DJHkhIeh0WO2ta2AcXQHYfldJDM6/gw5soOQxEjGF4kh2oUCHvRzBSuUG8g4o0/IvKtDtbuVbsJSIm07f8pBicTfpSMMFNWZN6lUQ0I2PogNs5bxJy7WzeDycO5KxirXRpbo2tSaoIvF/Ln32bSkuDJ2X5qQzCNqm2hJ6EFP0za+f+6Owb9Wupq6rS48QzZrR/VmOnLz4JzurZuSHkhiqp7yg6KRFKb62IbLTrpBtox/zK3MjlCRQ/XBszAm66ONC6oSm1riVTxLweIO6XgkasOjIxhwD8U7JB6NS71Je4PGjNtes0pET3jQe/Qff3z0VFQ5ntOVw1wi18qWirDt2/EoRd5Dfpg4/1usnRG0/Nhzbsqptg1gJvAolKIz5u9GKy9YN85N0RS+na8W0qbzke/urD8nCW111ejHcLr6Zhizb+JY2hYkdswdwOwjtBMabm3U+nWB6u4/X09eTV5P7owQXr96dXf/6u0P39+/+eHvb++///av393f3w0D/bN9DPfhEYhD7zOFviUK4fDwuPrGDPbwuPqu+FAf3lIhww+YBlZlwd/r1/vAN0PtwCQxERovQODvLZCRJe65O4nIPQP9ZW4cvH1W4N++u319d3d7d/e3279+N+Hrif/LJBKtZ9l2YH78+B4kRkLGgQ5U6IHCw2P+PKiYaWJ7XawoAYkrlKp9gvTwCEyIp860Q0MMqFk8TVmmpmJQn/zyXaB92bf9vudzjHy6Kb1luEKWt1+/xo8/v32R+0NeFmbS3Dm94Gifhm1SZWSGrPb+gusrb6j9x531gq/mQkxmRE4WghG+mAi5mFwZ+V5Vf9FKHRatxg2NvG193k/akIdIJOh7txEOmMwwjjGGSKRFn3ZDoEnYfmGpdXr/8mWazRiNVDaf0y8WR29dntoXXsbzS/9uyPkPzXI23SX9Yk6sBnp1A1/utgNxnuAZ7xGKMsOanz1a/8R3Ayz3+Z7AfDPr4wQYeafsa1th4nKNr19BtCSulNM99rvrIe4C6livW2wdBb+MGO28mSnBMl1vM4dfMMrcucZ2SPaq9miK86nUHHtpLk9eBbuAduM5Xji6G1Xdv+/Omn5wnm7g74cmTcXcdU/NYwNapkp9D/KecUC7J9TeDTXfuMdDuIsrmpnrXR0o7Ul0O0LOfTLXqinw9x7pdwPMSqsbXbW5qg8mjoelGML6TSo4LzoardGpGdLEkfvPTbhx2MFdHHcD2wYOeigP9Ji0nmChqki7UfdTqCPgM9C2KVgTHiqzBVC1DL7SOjLAMqNSGXaQNCMmFE7XpPPS3lHQNhAaczstkUyDL5vVcWuaXAbsAkgIdbHDxqNan09vL9T6bAe2DRxcoPXZ8n+KiU0b/QsHeyKfHYnP9UL25quJfiDvrxyYqvQ9uSbJ4Hdf8682/kx5mulp/qGEMkZ9p5phuv3Rxg05r7apX0lq8uz/AwAA//9UJQlt" } From 7bd88c98510cb339cd2224c43399f65765e600cb Mon Sep 17 00:00:00 2001 From: kasen Date: Fri, 14 Dec 2018 06:48:24 -0900 Subject: [PATCH 12/12] fix fields --- metricbeat/docs/fields.asciidoc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 6e7829bda056..4fe7f5b21692 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -22090,7 +22090,7 @@ All TCP listening ports -- type: integer -TCP established ports +Number of established TCP connections -- @@ -22100,7 +22100,7 @@ TCP established ports -- type: integer -TCP close_wait ports +Number of TCP connections in _close_wait_ state -- @@ -22110,7 +22110,7 @@ TCP close_wait ports -- type: integer -TCP time_wait ports +Number of TCP connections in _time_wait_ state --