From f045682dfecb02532ffdda907cdde3f146cebfe1 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Fri, 3 May 2019 10:18:49 -0500 Subject: [PATCH 01/10] add sockstat data to socket_summary --- metricbeat/docs/fields.asciidoc | 20 +++ metricbeat/module/system/fields.go | 2 +- .../system/socket_summary/_meta/fields.yml | 8 ++ .../socket_summary/_meta/testdata/sockstat | 6 + .../system/socket_summary/socket_summary.go | 28 +++- .../system/socket_summary/sockstat_linux.go | 126 ++++++++++++++++++ .../socket_summary/sockstat_linux_test.go | 41 ++++++ .../system/socket_summary/sockstat_other.go | 29 ++++ 8 files changed, 255 insertions(+), 5 deletions(-) create mode 100644 metricbeat/module/system/socket_summary/_meta/testdata/sockstat create mode 100644 metricbeat/module/system/socket_summary/sockstat_linux.go create mode 100644 metricbeat/module/system/socket_summary/sockstat_linux_test.go create mode 100644 metricbeat/module/system/socket_summary/sockstat_other.go diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 044af1ca15eb..4a1b2ed8a47e 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -25925,6 +25925,26 @@ Summary metrics of open sockets in the host system +*`system.socket.summary.tcp.orphan_sockets`*:: ++ +-- +type: integer + +A count of all orphaned tcp sockets. Only available on Linux. + + +-- + +*`system.socket.summary.tcp.socket_memory`*:: ++ +-- +type: integer + +Memory used by TCP sockets. Corresponds to limits set in /proc/sys/net/ipv4/tcp_mem. Only available on linux. + + +-- + [float] == all fields diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 27b315c5c450..02fae62bfc07 100644 --- a/metricbeat/module/system/fields.go +++ b/metricbeat/module/system/fields.go @@ -32,5 +32,5 @@ func init() { // AssetSystem returns asset data. // This is the base64 encoded gzipped contents of ../metricbeat/module/system. func AssetSystem() string { - return "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" + return "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" } diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml index 7962365884f6..7cf70f204be5 100644 --- a/metricbeat/module/system/socket_summary/_meta/fields.yml +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -23,6 +23,14 @@ description: > All TCP connections fields: + - name: orphan_sockets + type: integer + description: > + A count of all orphaned tcp sockets. Only available on Linux. + - name: socket_memory + type: integer + description: > + Memory used by TCP sockets. Corresponds to limits set in /proc/sys/net/ipv4/tcp_mem. Only available on linux. - name: all type: group description: > diff --git a/metricbeat/module/system/socket_summary/_meta/testdata/sockstat b/metricbeat/module/system/socket_summary/_meta/testdata/sockstat new file mode 100644 index 000000000000..f605ef3baba5 --- /dev/null +++ b/metricbeat/module/system/socket_summary/_meta/testdata/sockstat @@ -0,0 +1,6 @@ +sockets: used 249 +TCP: inuse 2 orphan 0 tw 0 alloc 12 mem 1 +UDP: inuse 2 mem 11 +UDPLITE: inuse 0 +RAW: inuse 0 +FRAG: inuse 0 memory 0 \ No newline at end of file diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go index 6ad29a7c2108..8da4b866e13b 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -18,14 +18,20 @@ package socket_summary import ( + "path/filepath" "syscall" + "github.com/pkg/errors" "github.com/shirou/gopsutil/net" "github.com/elastic/beats/libbeat/common" + "github.com/elastic/beats/libbeat/logp" "github.com/elastic/beats/metricbeat/mb" + "github.com/elastic/beats/metricbeat/module/system" ) +var debugf = logp.MakeDebug("socket_summary") + // init registers the MetricSet with the central registry as soon as the program // starts. The New function will be called later to instantiate an instance of // the MetricSet for each host defined in the module's configuration. After the @@ -43,13 +49,20 @@ func init() { // interface methods except for Fetch. type MetricSet struct { mb.BaseMetricSet + sockstat string } // New creates a new instance of the MetricSet. New is responsible for unpacking // any MetricSet specific configuration options if there are any. func New(base mb.BaseMetricSet) (mb.MetricSet, error) { + systemModule, ok := base.Module().(*system.Module) + if !ok { + return nil, errors.New("unexpected module type") + } + dir := filepath.Join(systemModule.HostFS, "/proc/net/sockstat") return &MetricSet{ BaseMetricSet: base, + sockstat: dir, }, nil } @@ -114,17 +127,24 @@ func calculateConnStats(conns []net.ConnectionStat) common.MapStr { // Fetch methods implements the data gathering and data conversion to the right // format. It publishes the event which is then forwarded to the output. In case // of an error set the Error field of mb.Event or simply call report.Error(). -func (m *MetricSet) Fetch(report mb.ReporterV2) { +func (m *MetricSet) Fetch(report mb.ReporterV2) error { // all network connections conns, err := net.Connections("inet") if err != nil { - report.Error(err) - return + return errors.Wrap(err, "error getting connections") } + stats := calculateConnStats(conns) + newStats, err := applyEnhancements(stats, m) + if err != nil { + return errors.Wrap(err, "error applying enhancements") + } + debugf("tcp %#v", newStats["tcp"]) report.Event(mb.Event{ - MetricSetFields: calculateConnStats(conns), + MetricSetFields: newStats, }) + + return nil } diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go new file mode 100644 index 000000000000..5fed6758672e --- /dev/null +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -0,0 +1,126 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// +build linux + +package socket_summary + +import ( + "bufio" + "fmt" + "os" + + "github.com/pkg/errors" + + "github.com/elastic/beats/libbeat/common" +) + +//SockStat contains data from /proc/net/sockstat +type SockStat struct { + //The count of all sockets in use on the system, in the most liberal definition. See `ss -s` and `ss -a` for more. + SocketsUsed int + //Total in use TCP sockets + TCPInUse int + //Total 'orphaned' TCP sockets + TCPOrphan int + //Sockets in TIME_WAIT + TCPTW int + //Total allocated sockets + TCPAlloc int + //Socket memory use, in pages + TCPMem int + //In use UDP sockets + UDPInUse int + //Socket memory use, in pages + UDPMem int + //UDP-Lite in use sockets + UDPLiteInUse int + //In Use raw sockets + RawInUse int + //FRAG sockets in use + FragInUse int + //Frag memory, in bytes + FragMemory int +} + +//get a list of platform-specific enhancements and apply them to our mapStr object. +func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) { + stat, err := parseSockstat(m.sockstat) + if err != nil { + return nil, errors.Wrap(err, "error getting sockstat data") + } + debugf("sockstat: %#v", stat) + data["tcp"].(common.MapStr)["orphan_sockets"] = stat.TCPOrphan + data["tcp"].(common.MapStr)["socket_memory"] = os.Getpagesize() * stat.TCPMem + + return data, nil + +} + +//parse the ipv4 sockstat file +//see net/ipv4/proc.c +func parseSockstat(path string) (SockStat, error) { + fd, err := os.Open(path) + if err != nil { + return SockStat{}, err + } + + var ss SockStat + scanfLines := []string{ + "sockets: used %d", + "TCP: inuse %d orphan %d tw %d alloc %d mem %d", + "UDP: inuse %d mem %d", + "UDPLITE: inuse %d", + "RAW: inuse %d", + "FRAG: inuse %d memory %d", + } + scanfOut := [][]interface{}{ + {&ss.SocketsUsed}, + {&ss.TCPInUse, &ss.TCPOrphan, &ss.TCPTW, &ss.TCPAlloc, &ss.TCPMem}, + {&ss.UDPInUse, &ss.UDPMem}, + {&ss.UDPLiteInUse}, + {&ss.RawInUse}, + {&ss.FragInUse, &ss.FragMemory}, + } + + scanner := bufio.NewScanner(fd) + + iter := 0 + for scanner.Scan() { + + //bail if we've iterated more times than expected + if iter >= len(scanfLines) { + return ss, errors.New("too many lines in sockstat") + } + txt := scanner.Text() + count, err := fmt.Sscanf(txt, scanfLines[iter], scanfOut[iter]...) + if err != nil { + return ss, errors.Wrap(err, "error reading sockstat") + } + if count != len(scanfOut[iter]) { + return ss, fmt.Errorf("did not match fields in line %s", scanfLines[iter]) + } + + if err = scanner.Err(); err != nil { + return ss, errors.Wrap(err, "error in scan") + } + + iter++ + } + + return ss, nil +} diff --git a/metricbeat/module/system/socket_summary/sockstat_linux_test.go b/metricbeat/module/system/socket_summary/sockstat_linux_test.go new file mode 100644 index 000000000000..c10fcf6759fb --- /dev/null +++ b/metricbeat/module/system/socket_summary/sockstat_linux_test.go @@ -0,0 +1,41 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// +build linux +package socket_summary + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/elastic/beats/libbeat/common" +) + +func TestSockstat(t *testing.T) { + base := common.MapStr{ + "tcp": common.MapStr{}, + } + + out, err := parseSockstat("./_meta/testdata/sockstat") + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, out.TCPMem, 1) + assert.Equal(t, out.TCPOrphan, 0) +} diff --git a/metricbeat/module/system/socket_summary/sockstat_other.go b/metricbeat/module/system/socket_summary/sockstat_other.go new file mode 100644 index 000000000000..8a0ccd20baad --- /dev/null +++ b/metricbeat/module/system/socket_summary/sockstat_other.go @@ -0,0 +1,29 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// +build !linux + +package socket_summary + +import "github.com/elastic/beats/libbeat/common" + +//a stub function for non-linux systems +//get a list of platform-specific enhancements and apply them to our mapStr object. +func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) { + return data, nil + +} From 1ae80278d63dfb3667eafd214161fd4adeacd3db Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Fri, 3 May 2019 10:22:47 -0500 Subject: [PATCH 02/10] fix linux tests --- .../module/system/socket_summary/sockstat_linux_test.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/metricbeat/module/system/socket_summary/sockstat_linux_test.go b/metricbeat/module/system/socket_summary/sockstat_linux_test.go index c10fcf6759fb..9fd69fccf597 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux_test.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux_test.go @@ -16,20 +16,16 @@ // under the License. // +build linux + package socket_summary import ( "testing" "github.com/stretchr/testify/assert" - - "github.com/elastic/beats/libbeat/common" ) func TestSockstat(t *testing.T) { - base := common.MapStr{ - "tcp": common.MapStr{}, - } out, err := parseSockstat("./_meta/testdata/sockstat") if err != nil { From 712a2a9f957125eb2e02335e85a72e78353ec0bb Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Fri, 3 May 2019 14:31:33 -0500 Subject: [PATCH 03/10] remove debug lines --- metricbeat/module/system/socket_summary/socket_summary.go | 3 --- metricbeat/module/system/socket_summary/sockstat_linux.go | 1 - 2 files changed, 4 deletions(-) diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go index 8da4b866e13b..b3b75cc97eaf 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -25,13 +25,10 @@ import ( "github.com/shirou/gopsutil/net" "github.com/elastic/beats/libbeat/common" - "github.com/elastic/beats/libbeat/logp" "github.com/elastic/beats/metricbeat/mb" "github.com/elastic/beats/metricbeat/module/system" ) -var debugf = logp.MakeDebug("socket_summary") - // init registers the MetricSet with the central registry as soon as the program // starts. The New function will be called later to instantiate an instance of // the MetricSet for each host defined in the module's configuration. After the diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go index 5fed6758672e..a0cd9a7c6de4 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -63,7 +63,6 @@ func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) if err != nil { return nil, errors.Wrap(err, "error getting sockstat data") } - debugf("sockstat: %#v", stat) data["tcp"].(common.MapStr)["orphan_sockets"] = stat.TCPOrphan data["tcp"].(common.MapStr)["socket_memory"] = os.Getpagesize() * stat.TCPMem From f5179cfa7af0f7e37ce4632d3cca0c36e65ced87 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Fri, 3 May 2019 14:32:14 -0500 Subject: [PATCH 04/10] remove debug lines --- 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 b3b75cc97eaf..c2765636f82a 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -138,7 +138,6 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error { if err != nil { return errors.Wrap(err, "error applying enhancements") } - debugf("tcp %#v", newStats["tcp"]) report.Event(mb.Event{ MetricSetFields: newStats, }) From 2956f2d5b043bcc251ec6b96ee9d601c56442222 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Fri, 3 May 2019 14:56:48 -0500 Subject: [PATCH 05/10] remove extra newlines --- metricbeat/module/system/socket_summary/socket_summary.go | 1 - metricbeat/module/system/socket_summary/sockstat_linux_test.go | 1 - 2 files changed, 2 deletions(-) diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go index c2765636f82a..a84b2ddecd49 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -125,7 +125,6 @@ func calculateConnStats(conns []net.ConnectionStat) common.MapStr { // format. It publishes the event which is then forwarded to the output. In case // of an error set the Error field of mb.Event or simply call report.Error(). func (m *MetricSet) Fetch(report mb.ReporterV2) error { - // all network connections conns, err := net.Connections("inet") diff --git a/metricbeat/module/system/socket_summary/sockstat_linux_test.go b/metricbeat/module/system/socket_summary/sockstat_linux_test.go index 9fd69fccf597..39ab53b92e16 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux_test.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux_test.go @@ -26,7 +26,6 @@ import ( ) func TestSockstat(t *testing.T) { - out, err := parseSockstat("./_meta/testdata/sockstat") if err != nil { t.Fatal(err) From e4f3645c72ad7a3a9704d4a9cad12ecf4d53a233 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Mon, 6 May 2019 13:45:40 -0500 Subject: [PATCH 06/10] misc fixes, moved around and renamed fields --- metricbeat/docs/fields.asciidoc | 42 ++++++++++--------- metricbeat/module/system/fields.go | 2 +- .../system/socket_summary/_meta/fields.yml | 13 +++--- .../system/socket_summary/socket_summary.go | 12 ++---- .../system/socket_summary/sockstat_linux.go | 31 ++++++++------ .../system/socket_summary/sockstat_other.go | 1 - 6 files changed, 52 insertions(+), 49 deletions(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 4a1b2ed8a47e..6d2f7734a9b9 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -25925,26 +25925,6 @@ Summary metrics of open sockets in the host system -*`system.socket.summary.tcp.orphan_sockets`*:: -+ --- -type: integer - -A count of all orphaned tcp sockets. Only available on Linux. - - --- - -*`system.socket.summary.tcp.socket_memory`*:: -+ --- -type: integer - -Memory used by TCP sockets. Corresponds to limits set in /proc/sys/net/ipv4/tcp_mem. Only available on linux. - - --- - [float] == all fields @@ -25979,6 +25959,18 @@ All TCP connections +*`system.socket.summary.tcp.memory`*:: ++ +-- +type: integer + +format: bytes + +Memory used by TCP sockets in bytes, based on number of allocated pages and system page size. Corresponds to limits set in /proc/sys/net/ipv4/tcp_mem. Only available on Linux. + + +-- + [float] == all fields @@ -25986,6 +25978,16 @@ All TCP connections +*`system.socket.summary.tcp.all.orphaned`*:: ++ +-- +type: integer + +A count of all orphaned tcp sockets. Only available on Linux. + + +-- + *`system.socket.summary.tcp.all.count`*:: + -- diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 02fae62bfc07..46e1ef19393f 100644 --- a/metricbeat/module/system/fields.go +++ b/metricbeat/module/system/fields.go @@ -32,5 +32,5 @@ func init() { // AssetSystem returns asset data. // This is the base64 encoded gzipped contents of ../metricbeat/module/system. func AssetSystem() string { - return "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" + return "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" } diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml index 7cf70f204be5..9b6ecc6a92f0 100644 --- a/metricbeat/module/system/socket_summary/_meta/fields.yml +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -23,19 +23,20 @@ description: > All TCP connections fields: - - name: orphan_sockets + - name: memory type: integer + format: bytes description: > - A count of all orphaned tcp sockets. Only available on Linux. - - name: socket_memory - type: integer - description: > - Memory used by TCP sockets. Corresponds to limits set in /proc/sys/net/ipv4/tcp_mem. Only available on linux. + Memory used by TCP sockets in bytes, based on number of allocated pages and system page size. Corresponds to limits set in /proc/sys/net/ipv4/tcp_mem. Only available on Linux. - name: all type: group description: > All TCP connections fields: + - name: orphaned + type: integer + description: > + A count of all orphaned tcp sockets. Only available on Linux. - name: count type: integer description: > diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go index a84b2ddecd49..d3c34b01f4b4 100644 --- a/metricbeat/module/system/socket_summary/socket_summary.go +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -18,7 +18,6 @@ package socket_summary import ( - "path/filepath" "syscall" "github.com/pkg/errors" @@ -26,7 +25,6 @@ import ( "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/metricbeat/mb" - "github.com/elastic/beats/metricbeat/module/system" ) // init registers the MetricSet with the central registry as soon as the program @@ -52,14 +50,8 @@ type MetricSet struct { // New creates a new instance of the MetricSet. New is responsible for unpacking // any MetricSet specific configuration options if there are any. func New(base mb.BaseMetricSet) (mb.MetricSet, error) { - systemModule, ok := base.Module().(*system.Module) - if !ok { - return nil, errors.New("unexpected module type") - } - dir := filepath.Join(systemModule.HostFS, "/proc/net/sockstat") return &MetricSet{ BaseMetricSet: base, - sockstat: dir, }, nil } @@ -135,8 +127,10 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error { stats := calculateConnStats(conns) newStats, err := applyEnhancements(stats, m) if err != nil { - return errors.Wrap(err, "error applying enhancements") + m.Logger().Debugf("error applying enhancements: %s", err) + newStats = stats } + report.Event(mb.Event{ MetricSetFields: newStats, }) diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go index a0cd9a7c6de4..fe8824e5b663 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -23,13 +23,15 @@ import ( "bufio" "fmt" "os" + "path/filepath" "github.com/pkg/errors" "github.com/elastic/beats/libbeat/common" + "github.com/elastic/beats/metricbeat/module/system" ) -//SockStat contains data from /proc/net/sockstat +// SockStat contains data from /proc/net/sockstat type SockStat struct { //The count of all sockets in use on the system, in the most liberal definition. See `ss -s` and `ss -a` for more. SocketsUsed int @@ -57,20 +59,26 @@ type SockStat struct { FragMemory int } -//get a list of platform-specific enhancements and apply them to our mapStr object. +// applyEnhancements gets a list of platform-specific enhancements and apply them to our mapStr object. func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) { - stat, err := parseSockstat(m.sockstat) + systemModule, ok := m.BaseMetricSet.Module().(*system.Module) + if !ok { + return nil, errors.New("unexpected module type") + } + dir := filepath.Join(systemModule.HostFS, "/proc/net/sockstat") + + stat, err := parseSockstat(dir) if err != nil { return nil, errors.Wrap(err, "error getting sockstat data") } - data["tcp"].(common.MapStr)["orphan_sockets"] = stat.TCPOrphan - data["tcp"].(common.MapStr)["socket_memory"] = os.Getpagesize() * stat.TCPMem + data.Put("tcp.orphaned", stat.TCPOrphan) + data.Put("tcp.memory", os.Getpagesize()*stat.TCPMem) return data, nil } -//parse the ipv4 sockstat file +// parseSockstat parses the ipv4 sockstat file //see net/ipv4/proc.c func parseSockstat(path string) (SockStat, error) { fd, err := os.Open(path) @@ -100,10 +108,9 @@ func parseSockstat(path string) (SockStat, error) { iter := 0 for scanner.Scan() { - //bail if we've iterated more times than expected if iter >= len(scanfLines) { - return ss, errors.New("too many lines in sockstat") + return ss, nil } txt := scanner.Text() count, err := fmt.Sscanf(txt, scanfLines[iter], scanfOut[iter]...) @@ -114,12 +121,12 @@ func parseSockstat(path string) (SockStat, error) { return ss, fmt.Errorf("did not match fields in line %s", scanfLines[iter]) } - if err = scanner.Err(); err != nil { - return ss, errors.Wrap(err, "error in scan") - } - iter++ } + if err = scanner.Err(); err != nil { + return ss, errors.Wrap(err, "error in scan") + } + return ss, nil } diff --git a/metricbeat/module/system/socket_summary/sockstat_other.go b/metricbeat/module/system/socket_summary/sockstat_other.go index 8a0ccd20baad..071b6faecca4 100644 --- a/metricbeat/module/system/socket_summary/sockstat_other.go +++ b/metricbeat/module/system/socket_summary/sockstat_other.go @@ -25,5 +25,4 @@ import "github.com/elastic/beats/libbeat/common" //get a list of platform-specific enhancements and apply them to our mapStr object. func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) { return data, nil - } From 9b89f6c57c255d7b6b2d258d362e63d4617915cc Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Mon, 6 May 2019 15:18:30 -0500 Subject: [PATCH 07/10] add udp memory field --- metricbeat/docs/fields.asciidoc | 12 ++++++++++++ metricbeat/module/system/fields.go | 2 +- .../module/system/socket_summary/_meta/fields.yml | 5 +++++ .../module/system/socket_summary/sockstat_linux.go | 1 + 4 files changed, 19 insertions(+), 1 deletion(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 6d2f7734a9b9..22180487f313 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -26045,6 +26045,18 @@ All UDP connections +*`system.socket.summary.udp.memory`*:: ++ +-- +type: integer + +format: bytes + +Memory used by UDP sockets in bytes, based on number of allocated pages and system page size. Corresponds to limits set in /proc/sys/net/ipv4/udp_mem. Only available on Linux. + + +-- + [float] == all fields diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 46e1ef19393f..6594880af022 100644 --- a/metricbeat/module/system/fields.go +++ b/metricbeat/module/system/fields.go @@ -32,5 +32,5 @@ func init() { // AssetSystem returns asset data. // This is the base64 encoded gzipped contents of ../metricbeat/module/system. func AssetSystem() string { - return "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" + return "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" } diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml index 9b6ecc6a92f0..25c4ca4ef9f6 100644 --- a/metricbeat/module/system/socket_summary/_meta/fields.yml +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -62,6 +62,11 @@ description: > All UDP connections fields: + - name: memory + type: integer + format: bytes + description: > + Memory used by UDP sockets in bytes, based on number of allocated pages and system page size. Corresponds to limits set in /proc/sys/net/ipv4/udp_mem. Only available on Linux. - name: all type: group description: > diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go index fe8824e5b663..2433b012e897 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -73,6 +73,7 @@ func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) } data.Put("tcp.orphaned", stat.TCPOrphan) data.Put("tcp.memory", os.Getpagesize()*stat.TCPMem) + data.Put("udp.memory", os.Getpagesize()*stat.UDPMem) return data, nil From 8b14f21f95460737eaf84d7b36ce73aac4a38428 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Tue, 7 May 2019 08:39:52 -0500 Subject: [PATCH 08/10] change field name of orphan sockets, update test --- metricbeat/docs/fields.asciidoc | 2 +- metricbeat/module/system/fields.go | 2 +- metricbeat/module/system/socket_summary/_meta/fields.yml | 2 +- metricbeat/module/system/socket_summary/sockstat_linux.go | 2 +- metricbeat/module/system/socket_summary/sockstat_linux_test.go | 1 + 5 files changed, 5 insertions(+), 4 deletions(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 22180487f313..d810c35196e4 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -25978,7 +25978,7 @@ All TCP connections -*`system.socket.summary.tcp.all.orphaned`*:: +*`system.socket.summary.tcp.all.orphan`*:: + -- type: integer diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 6594880af022..f2cb76b59b24 100644 --- a/metricbeat/module/system/fields.go +++ b/metricbeat/module/system/fields.go @@ -32,5 +32,5 @@ func init() { // AssetSystem returns asset data. // This is the base64 encoded gzipped contents of ../metricbeat/module/system. func AssetSystem() string { - return "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" + return "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" } diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml index 25c4ca4ef9f6..4720178b599e 100644 --- a/metricbeat/module/system/socket_summary/_meta/fields.yml +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -33,7 +33,7 @@ description: > All TCP connections fields: - - name: orphaned + - name: orphan type: integer description: > A count of all orphaned tcp sockets. Only available on Linux. diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go index 2433b012e897..6087abd51123 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -71,7 +71,7 @@ func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) if err != nil { return nil, errors.Wrap(err, "error getting sockstat data") } - data.Put("tcp.orphaned", stat.TCPOrphan) + data.Put("tcp.orphan", stat.TCPOrphan) data.Put("tcp.memory", os.Getpagesize()*stat.TCPMem) data.Put("udp.memory", os.Getpagesize()*stat.UDPMem) diff --git a/metricbeat/module/system/socket_summary/sockstat_linux_test.go b/metricbeat/module/system/socket_summary/sockstat_linux_test.go index 39ab53b92e16..03d1f30afea7 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux_test.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux_test.go @@ -33,4 +33,5 @@ func TestSockstat(t *testing.T) { assert.Equal(t, out.TCPMem, 1) assert.Equal(t, out.TCPOrphan, 0) + assert.Equal(t, out.UDPMem, 11) } From 9feeffca69b4ddbcb1bca51e499b61075d32c5d3 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Wed, 8 May 2019 08:37:06 -0500 Subject: [PATCH 09/10] put TCP orphan data in the proper place --- metricbeat/module/system/socket_summary/sockstat_linux.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go index 6087abd51123..536038a4efbf 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -71,7 +71,7 @@ func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) if err != nil { return nil, errors.Wrap(err, "error getting sockstat data") } - data.Put("tcp.orphan", stat.TCPOrphan) + data.Put("tcp.all.orphan", stat.TCPOrphan) data.Put("tcp.memory", os.Getpagesize()*stat.TCPMem) data.Put("udp.memory", os.Getpagesize()*stat.UDPMem) From e72c8d1a9d5014cf63bd9e7cf2086d6f34623d22 Mon Sep 17 00:00:00 2001 From: Alex Kristiansen Date: Mon, 13 May 2019 15:59:07 -0400 Subject: [PATCH 10/10] prevent repeated calls to GetPageSize --- metricbeat/module/system/socket_summary/sockstat_linux.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go index 536038a4efbf..9c6d5ac2b357 100644 --- a/metricbeat/module/system/socket_summary/sockstat_linux.go +++ b/metricbeat/module/system/socket_summary/sockstat_linux.go @@ -66,14 +66,15 @@ func applyEnhancements(data common.MapStr, m *MetricSet) (common.MapStr, error) return nil, errors.New("unexpected module type") } dir := filepath.Join(systemModule.HostFS, "/proc/net/sockstat") + pageSize := os.Getpagesize() stat, err := parseSockstat(dir) if err != nil { return nil, errors.Wrap(err, "error getting sockstat data") } data.Put("tcp.all.orphan", stat.TCPOrphan) - data.Put("tcp.memory", os.Getpagesize()*stat.TCPMem) - data.Put("udp.memory", os.Getpagesize()*stat.UDPMem) + data.Put("tcp.memory", pageSize*stat.TCPMem) + data.Put("udp.memory", pageSize*stat.UDPMem) return data, nil