diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc index f625ce48cba4..f82ccc865b9d 100644 --- a/CHANGELOG.asciidoc +++ b/CHANGELOG.asciidoc @@ -73,6 +73,7 @@ https://github.com/elastic/beats/compare/v6.4.0...master[Check the HEAD diff] - Move common kafka fields (broker, topic and partition.id) to the module level to facilitate events correlation {pull}7767[7767] - Add `metircs` metricset to MongoDB module. {pull}7611[7611] - Add fields for mermory fragmentation, memory allocator stats, copy on write, master-slave status, and active defragmentation to `info` metricset of Redis module. {pull}7695[7695] +- Add experimental socket summary metricset to system module {pull}6782[6782] *Packetbeat* diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 6d68765cbf73..f8520f18d08b 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -19476,6 +19476,98 @@ type: keyword Name of the user running the process. +-- + +[float] +== socket.summary fields + +Summary metrics of open sockets in the host system + + + +[float] +== all fields + +All connections + + + +*`system.socket.summary.all.count`*:: ++ +-- +type: integer + +All open connections + + +-- + +*`system.socket.summary.all.listening`*:: ++ +-- +type: integer + +All listening ports + + +-- + +[float] +== tcp fields + +All TCP connections + + + +[float] +== all fields + +All TCP connections + + + +*`system.socket.summary.tcp.all.count`*:: ++ +-- +type: integer + +All open TCP connections + + +-- + +*`system.socket.summary.tcp.all.listening`*:: ++ +-- +type: integer + +All TCP listening ports + + +-- + +[float] +== udp fields + +All UDP connections + + + +[float] +== all fields + +All UDP connections + + + +*`system.socket.summary.udp.all.count`*:: ++ +-- +type: integer + +All open TCP connections + + -- [float] diff --git a/metricbeat/docs/modules/system.asciidoc b/metricbeat/docs/modules/system.asciidoc index 5a1fa7db167c..bffa3adc06df 100644 --- a/metricbeat/docs/modules/system.asciidoc +++ b/metricbeat/docs/modules/system.asciidoc @@ -131,6 +131,8 @@ The following metricsets are available: * <> +* <> + * <> include::system/core.asciidoc[] @@ -157,5 +159,7 @@ include::system/raid.asciidoc[] include::system/socket.asciidoc[] +include::system/socket_summary.asciidoc[] + include::system/uptime.asciidoc[] diff --git a/metricbeat/docs/modules/system/socket_summary.asciidoc b/metricbeat/docs/modules/system/socket_summary.asciidoc new file mode 100644 index 000000000000..e0c54bb3fe3e --- /dev/null +++ b/metricbeat/docs/modules/system/socket_summary.asciidoc @@ -0,0 +1,17 @@ +//// +This file is generated! See scripts/docs_collector.py +//// + +[[metricbeat-metricset-system-socket_summary]] +=== System socket_summary metricset + +experimental[] + +include::../../../module/system/socket_summary/_meta/docs.asciidoc[] + + +==== Fields + +For a description of each field in the metricset, see the +<> section. + diff --git a/metricbeat/docs/modules_list.asciidoc b/metricbeat/docs/modules_list.asciidoc index 97c939dff8c4..c3884bab9d32 100644 --- a/metricbeat/docs/modules_list.asciidoc +++ b/metricbeat/docs/modules_list.asciidoc @@ -119,7 +119,7 @@ This file is generated! See scripts/docs_collector.py .2+| .2+| |<> |<> |<> |image:./images/icon-yes.png[Prebuilt dashboards are available] | -.13+| .13+| |<> +.14+| .14+| |<> |<> |<> |<> @@ -131,6 +131,7 @@ This file is generated! See scripts/docs_collector.py |<> |<> |<> +|<> experimental[] |<> |<> beta[] |image:./images/icon-no.png[No prebuilt dashboards] | .1+| .1+| |<> experimental[] diff --git a/metricbeat/include/list.go b/metricbeat/include/list.go index 95773e728e58..917d8588d98c 100644 --- a/metricbeat/include/list.go +++ b/metricbeat/include/list.go @@ -153,6 +153,7 @@ import ( _ "github.com/elastic/beats/metricbeat/module/system/process_summary" _ "github.com/elastic/beats/metricbeat/module/system/raid" _ "github.com/elastic/beats/metricbeat/module/system/socket" + _ "github.com/elastic/beats/metricbeat/module/system/socket_summary" _ "github.com/elastic/beats/metricbeat/module/system/uptime" _ "github.com/elastic/beats/metricbeat/module/traefik" _ "github.com/elastic/beats/metricbeat/module/traefik/health" diff --git a/metricbeat/module/system/fields.go b/metricbeat/module/system/fields.go index 481795680011..e2a9c01a4501 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 "eJzsXd1vIzeSf5+/ouDDIvadrRnPbrJ7fjhgktngDCQZYz6wC9wdNFR3SeKaTXZItjTKX3/gR393q7ulltQTxA8JxpaKvyoWi1XFYvEOnnH3AGqnNEYvADTVDB/g6oP9xdULgBBVIGmsqeAP8F8vAADcH0FpohMFEWpJA3ULjD4j/PD0CQgPIcJIyB0kiqzwFvSaaCASIRCMYaAxhKUUEeg1gohREk35yqOYvQBQayH1PBB8SVcPoGWCLwAkMiQKH2BFXgAsKbJQPVhAd8BJhAU2zI/exeazUiSx/00DK+bns/vaZwgE14RyBUwEhHlqKX8z//niuMWxAyEx+2XT6HsQFFDcGToFKEaeHgEshQQCivIVQzseiCUQiBKmqf1eQYLpT1lo6U+ViSIjNCz9OmWFCb6q/GEPN+bHQP/BoOJJtECZoyp98t/gCWWAXJMVqkZAiUI5iwPdCEsFhGE4XzJBqh9YChkR/QCxoz8M/Mc1pl8kKytow46mEYKKkWug3AIDFZMAW3grcaBp8KzGEa0BRyKRcH0kMK8vUxTuM0qObAgXIwq4U8ID0HEa4PQkLDgwsb2LJRWS6h3EUgSoFKo+3JxN0oeipCGboMwtqh7Az6fIPQCJLaF6grLkYIDBteAQUvV804+Pc9qIYfjkr9MTskK5oYFxzYxLtyY8ZOYfayLDrfHmKNcoZRLrzvUofz2f6EdDrcRSf03zYvAexuGl5+YA5BoJm97MUA6UbwRLuCZy50zAYmfjnA2VOiHMfmO7pgztb9e72IhECVkbbEtUSV5Cr1GmW6CQs9oX3mwIZWTBEARnO7N5fuL0Sy9BntMuTldAWSwXJ0eFckGc1KJJw5WJmNVx0ZkJ88acKBebpRNlqUMsUXnvy86AUHrmPiz4HTfrh9HfsBomQmFlKNhSxmBNNmgCVPKFRkkEG8ISu2g+37969Sf4dzfcZ0u7Riwfp0SXMIkk3IEmz0Y/qPJUKdcCSBBYtXO2ZVMn2oDFQPldh6bwjtdTBOq2RnYnEggId5NWFHmWvFlJJBql+QV3coMfhQT8QqKY4S3QJfy5RtaplPk60fDdqz8ZaLdGr5xy+bTHLIiTWSrNz057Fgj3f2udnN9XCPv7ChK/3vDr9xLtfEVe6x9+eQOHf3i343i3WuiJCtL4gqjAsW131MeQoVWcx3f/MFaozSn5JfeMevknxpOapAiGpqkny8jQjX6ajBy120+Tpf5b/kTxH7DvT5OT0Tf/r4rNQz2AaTL5tboBU5NmHy/gNk2EKAxTIec5GxtcN/Be8Rg+1rJ7X8vJ9JTPdL+OU9AJHiZO+hDu0kchh++Il0Z+6Cb3x9lDUSZGT6l4URXFkOMHQ6Jw/mD+CY/vsjKynjV46c/wMwrz38b5fMbdVsjqwYHPHz+ACsn98Om27Jkhu5QNJSVs7jbPAfB6QvhG+RHScjf4uKYKIrIDLjQs0CjHhoZuGyeM5UKv0fQ5+g6GJJJwZg88Rlw81lMqeBhmEKMyZoaMyqgkMBq+TBjbdeDbSqrx5ADtKAcitBJc7HT/E7XUFWz60gHgLRkLowwb3nH4ifLkizviotWhoOIHKgy0kJ6SPeyJGfWaxoEolURGMvZToOhv1g/99v51rxm8vIAMDo18HBmlxHqKqUa1W2xWrcy+c0K1jygzMUEgeKj89ubNil2xvSb2YhDdmu10Fk8NsBljKMw++PjyXTdAE73N7GxL/DVBpWcRyhWqeYxyrjBoxN4UYXaArx7V22Xuh1Rgx7Sn5OA4cSe2W5QIvyaYYAha2MUQ4oZ2xjaeLaci5+XLjnlqxkrzddaJytFTpWroC3weMEHnnZlxObEz4hnYs9uMwMb3+X6b+b41zFXfvXlL656aM3LkpueULKV6RjarudkZx+WHbFCSFbo995rydLO+MSwajnpqXj8LYG3HiTmxYwBDvtLrkzBBTPh6GuyFkHkpZA67ca1rYWIbEwpj2A+5C5tx3rq7H69GbgTHiFGn4jZ/Y5l6fPlu3PlYJGo3HjdPzRnjMJHGOdmuabAus9BujK8XhIdbGuo1JJoy+hsxw1oh5J+6mcFb93FFdCLdR0QQJMZhdrVaeamdgoAJZae+XD2XimRJGZbu4sFBeYycTK2aMv/TGEWVJM3NnCnKsSkLm2fOhzbSJBwSHku6oQyN52Oz5ZS7YWaN0N30zQemXAalVYpFfg/w+WWIm5fmr/efGxGZcU8AxdCoQsEv+i/NIGwKcB4L2pJ7OBiLJWzWoKVdk00zGqutJwxkDH3gIkRltMWsavubei6vAEniRbV9v1YbdPOxpVaQl0Q8RGhW7mfNhBRkt19iicLzprLMgAPhXf7otQJ638lpporKbDBH7WNepRylwlZW2MTS3DxZrSSuSJacJ4w5k1Mpt8+/evR9gkPTs7+UzY9HA0uRVOON0vI5Yll/bDB7Lfrmhmpw7/dpffPM1hlHZecn5xpCEahajNUgddhvgfeKogt9DWeTXwleiNYCVtZAFaBZLBcDaFdqB8Amc3w+hM7sXVugMUuUlelN3RlmgoTHmA/j/BsaaXRz5IK/ur8aaoTNnyhfzZfEBOUPxukfZoh/KsDPAg9GlIaI8kRj8xq++nZKSL/1WFsMztX9pNDeN8Btxm2Loi6lEw26ACHNTkn7FTvV2bnUVDQrzBgcXUy7WrTqSJ7sh5o5Ou01xpp1dn2KjnLvHIlaisJ3QBohPXG2sMPuaw53d0eb84Ubn8wW2wvWGaNaF5/ltUbWo/JznsVCrgbEpc1CgcqWglAesCTMPhwI7s6dF7vUnQxIsEYFhNf9r0WyXKJUcK0wi1W9aEigE8JmFTdk8uFYr4l1vB3mr9eRvLHU8h5lGNpKNiO5Li9+r7fcuCLgDB6pZ6ggz4IOPmqQ6I2hcjlfapQIeYCwQL1FfxfXq7Q9Zy3mavwMNV7TNj/VT0KIMfJQpZb33QeXJ4uERAhRE8rULcTWDEKwxuA5i5ELOvy5RSXg8jGUF3fzkn/UNkNOWJAwG8gviJmWgiyywhWq7eqnSqv0jKhAs3FoG2nk9iG1B5bouw//NCSpAgIqiapWKZ1Yykmg6Saf13cc/kF5KLbq1n8ff62vNi9akc2V/3rfuWqxOdDH7kCn7ek5c3UbRGpLp6uOcEuq5qbdEMUSl/TLA1z9j2Xr/6o+Tzm/YTYLSyX3JYz7QJWmgTKOg9Unf7xjcJTaLKYq1pTB7E5HXDiYzpnpq0qXsrXWGxmG91JmKrPLB4h3eis16Sf4lIt1ssK4djP2AovVAAGL5OLrtLH4ucZa84Tk+d4CQ/7kJBaCTX3d/lzw9igHwkyYZqYoZ2eMtdHBwFFrolwVUNKr1uILGMkOjaM6uat4sBIZR1ZuDk9Nj8NIigIWibZRXZM+DeRMJdK4d5dlTGxQBiKK6OClEeKSJEw3nbr05uGI9f3WDe9qyJZCNoLPrqig3gr5/KIKb0jex9MoJH78b4qXbUo9m9O/2wtSy8rZxvnu2aBeD0wF2hRbFXyfSzci0Wc9la7eHDAxb1f9Fr8oQokB0u7aOSPImATPqE9TEuFp9xTY6ZDIDElPwVA+QymFPI1YHGl/JdAhonzVY67OhUkhD7sRUT4LpYjj2q45DiLKAxHZoig/d3lBpR+2h8ROCVAkeiX2AyymaqkCwrZkV9+JXhnn/S2RW+NB8hC+//AWFhiQRKFPnRhfQGIspM5PR9qvV6YC8BdHj9qPPI3CfuR/YzYjEhJNbovPCdwW32moPHIA59iP+qSLPQPlnQZKV4iJPtGglnSlwu9KJpxTvrpqRhOP9nhCEUhMWwpq4hONRyRyvWfY1UmGdcF026BBFDLKR57qZcIYGG+X8PDOkHfhoRZm8qV2zruDd+vPbcwq1g2JcCJXSWQz7ApjIolf/g0lLMXeG+MvmZRqmlC2NcTW3AW2fWdYZGoGj/mnGrAABIT768shapQR5Rje+mpJZKHr1OkNTkbpm7rh5EmEkgZAQ+SaLilKuP70+PamnH22VeaOsD8lU/uIhiIi3hBT5R0zwyFR8Nn97X9Txj63aNW2WZMPFn+QSLt4jKtsVCWk0l5l2aXzkUn+Y4FXZZsC1HWq0DPAHRk0c4F808iFWPwLa6kK98v5kXwi31ApuNF42BBJDUrVvnpc/2CzBzVd1C3x+aNE/P7D21vHsNul3n2Af7ZMYKlVM4yX3/vh6dOdijGgSxoUE3tx3uZhaOqutdkOdIXHPfOlDZ0vdHFD29eFpwrWtUyy/tCJ0GYtmA1YlxlVlAfotMfb2TZZd7d4hAunqyvNR7wrmM2F5TSrrEni0Dobj7rggyoaUUakP/BpHPZPZpRMkMUBQqpiRna5E6pFnG51afeReqOJZuG2NM76qiSMm1JkW6Zc9PwLjcdrxU15cZHdczRIwusnDJ5pKSJ4Vb8kVRXxnk5XcGa70NwBqwrY6cQp8bpChL3Tu0eexno0XS7M0YX1mGEIOoNpmzYwT4VoGwKZobHFgW081O9ZwuLOLobuR137Xdd+daFEbq4BaVcmH6QWxb0me1RAKnWxYyaD/j0q6+fCB9Twgf6Gs8oybGBIBEESU3c2Zb1a/5nr929+vtnP6vQs83j8qTWRl1JCO3bYxEyiWm+uNccTBxSp/UgZZp8R0ntIaaLGbVoKvTq5wwaqCq70sqFrmSs7MnuX97LHNhkiRn7UplC5qFeWgbL0e+8EjEZUz5RYDj6t7asgYqndKOmZfgf0zKdoJFmKlQq0A8JNAB6sjbMRVv0cooHwnd2VukSxJrVQbyxRGNKnEkWBthGF7Z+3QJAkbYoqhdAt4WHTwjt4Sf6c3tLjHo/Ke264kWyvFHs737rcRD27crwIy0+gpj/+W9n1P4l58rjmYqyJ8oTUmsa2iKGeZxH8zojDU7YCVFgawMqvK7XQvdRrOUDoyJ70EDB4bXp8a0MVo0nC3oF03CggSomA2jTWluq1SxgZMTd79i67ZTsj8G80kJTq41uXqvD9qFLqhfSTf4GmkSpZ7DklK4ooJnp9OiEZ6mkxoNcjW3VEN1j5tUoWLsr4RrnbpO7y+iCR2dHOIbR6Rgf2rtkBEgviJJcFqGCNYcLQPbJMbGs5d9+FqOesdsOvo0aab9x3UvssuJaCMW/ZtiLLBGdDSXULP/z4wRqQ9x+biZq/K0146MCkjQ3ZDpaEypyUtzOxFMZeUMEJa0ghWunYuzouk5oFVWnhdzqNWZXyFulqrWfw/mMBRiNdiYT5CK0CSqFWhce2GuPPRn8U8ubG5QmwQvZXJdI2KARWdIPc+J5U7Kt/ajdm0GXQoMd6haoGPr5NszFV7dkLoMVcHASheRGYn6dDzEYrtSZzspfJYKlmfsIaS52gyyEZwqodx86F77ce0UCKtN+fLRISW5C4ShiRZldsJeVE8o1K7YQWVpclKpHIABWotUhYaP0SzGrBBsjk10RocnqRfKxcW2oVjFvIhDVfA7CQUjNJimtUJjxdn4KjX5twTRSEuKTO7WuXclE52i4xNUnPhmqnlt0bboufVih9ttAeq/mkDBqDly0ki6do8FqJlhoApU5jSayzQrY8HSz01rFdknHiheLc7yhR9hTvNRilp6t164P8VfFKPeH1mq3Ldvm2rFeqDlioUs9kwm2oNQVh2OS24CtU9iKRpjwRifJrrpUw5ZUQpbyI3aOdzVLrKSZ359XBOLWY8spVb2psfeKGMGWNTmnBmEVRNjHtxs0sbSsKZCTeX15dZ12vpdCaYXh2IRhdUW2zunA3/Tw2uLZM0oa3QNOftLB56451jW1Pq530GndeQF/WJLEtUWxX8+Veu1Qwd0arSzPk8gFUgt0L+5r/qsT5ybfQLD+d9uRz7fKuKQdOuCj1GfQrLZuPDgejaZ76xUwk2JMF7hU3+SgobXDWUBKW/vzhTWc/F/am/fnsebzG4sNFBUUv3WA3JqAYP3fo+6A17l4zHIfXjJci+Ay4LZCIRNhW3t6ML32m8GwIr92B7c0QqDHK5gwL7C8bSn9K5UPHa1bGZc16ZmwLDkiCtf1oRcP2bN9UdavY3qNZGGY9/fUynxZ2pbV/GNATGdDhhjLCaGZP0FoPhqHPCu06WRzAeLHbij/cW+xa01/XaYOBvm5RznBEvkyH6TVmWcFi+42xOXfnXVPkOk+9uE2m3D7CcJtWGZu4vX37JMEab1yY0pCvdg/u5557ovruD0Z6S0JZcvp8Svms10culqF11rTCHftdV+b0Brak3YuSZrvoHbFFGKnt1GzDGtMOHmlBcclQ2C4g9iq860Lo11ArvTHXViasqdqVWpmN2YzrwioJZY8jcaywJm+K0kySV7iq0Oxk78+TjG2A1HZKJqi62OyEtlK8rs26NVYDjdLzVP0VXyJ6Mrflefp+S1UEne5LK9Xhkpm8MRHLinz2GYj2LOEhhuN5mq5Ldd7G9F0M7bkO4kmaipKNMJvMxx+esv6F9XbxQxidqmko2oQqxw02oiM5dpj1tGL6GuyEF1ZVTjWD0SWlgz2NTFrTNBrViWw/rBruX7iEpesDOCdcNPfA6C2AEXXlDRd8F4lE5R6ojXVBcPB9CxkSpe8kBsg1293Z1Xb90/tP7QJiVOnSBd4oXiq4VusIo5vbocaoJDwTpZ9ZeD9ShncLEjznxem5cH56/ylj9wCurKzPzM+T2SDswGPP0ZqiJDJY04CwuRPVfFqmsZg2ziKxFLb3nrJ+DgU74Wxf+8ntKOJS22lKK4/IesutlWRZnofJLe2o+vVY0qwHbNFclFZee4BbXZEHSeoCZrNdUs0GtVFGB2hHROIYw2lx/MG/Ae64vXMQwf/PvqvTborHtTkxWeHcdm47e5GMsREku11Rjk61pKsVSgzNJ/YlwCz0gfrwLyHnXwHfFmgH43D1s/nUlfungrVRIZ7fXfHJANdlme3sHRYt9oW/rkGJbRVhL9eEtHi7o6dGqXlr2uUEhWe216P5r60+E4WG6dRdynPPbPUuuSzyIZK2XONpGRFJIUg7lpV9F3J7sXKObfE6bzkjCVe+C1LWRvjmFrhoz/uO67hKpeZm5MlI7ZdK20KxBJIJslFew0pntiSeDK8fsmOPA2cv4bihgSaLCe34PxfSsXlTJ4kBIzTCsBenKZcL9kybbPiAcpnvmQiKjVL/qJIZu0rmgCIZV004FY2tPvfoDI+1NUuU0mX73Lst/qXMhVUq9yRyewDTflgzSExUnKfqMhfA48t3aStJwW2Zv5G2q5Az7B/OuK3Dxvxqva89du8cMxrsWjtWzlQSRaT8ghbVDB/gyfuXH+ofGNra0pMoNVUuXIxGBb4tY/NbXyd/c6vXu1qFXrsZbOEfVq/iLdw4cYyNhKTQv9wLbAgWGvZ/Ib03EEN0EArFEONTiCQlPAyNHrNrbQGMozsIy28iWtDxZ8iRHYQk4c9cbKsR2PFQcgyFuxVrdK1aTWTCQv6Nd2y0pLgxxlGauMUjqtsxSehRz7NWvn/prrm/FFp/uv2geYZsaovq3XzkBrop3Ts3JT2QmPg+PU0ZSWGKD064FJ4bZM/4p7T3doSCHIqPfjVjso7MuKAKAZwlXsSzFixskY5HonY8OIGV81D8ru3RuPyUtNdMzLj1NatE8IxHvcn+8YcnT0Xl4zldOc5vcP1eqWi2fR0PM6R91IeJ87/F1hlBy489DKacatslZQZPQim6YP4CsfKCdePcZo3R60ldIW3OG3l3d/kliWit9UQ/huPNX4Yx+yYMpe3TYcfsAGYfYp3R5v4/tV9nqO7/8/Xs1ez17N4I4fWrV/cPr95+/7eHN9///e3D377983cPD/fDQP9kH4R9fALi0Pt0mu8bQjg8Pm3+YgZ7fNp8l32oD2+xkL1f78/4e/36EPhmqA5MEiOhcQICf2+BjCxxz91ZRO4Z6C9z44sdsgL/+t3d6/v7u/v7v979+bsZ3878X2aBqD1N1oH56eN7kBgIGTa0aUIPFB6f0icyxUIT2xBiQwlI3KBU9WOWxydgQjy3xuYVMaBm4TxmiZqLQb3i87dxDmXfNsVeLjHwOZn4juEGWdqj/Bo//vT2JvWHvCzMpLnDbMHRPo9apcrIAlnpDQLXfN1Q+4976wVfLYWYLYicrQQjfDUTcjW7MvK9Kv6ill/L+nEbGmlv97TpsiEPgYjQNzgjHDBaYBhiCIGIs2bmhkCVsP3CWuv44eXLOFkwGqhkuaRfLI7eujy3r5yM55f+3ZDzH1qkbLqb7NmcWA306ga+JqwDcZoFGe8hhjwNmR7QWf/Et8zL9/mewHzH59MEGGk76WtbhuEScq9fQbAmrt7RPXjb9Rh1BnWsFx72joJfRox23iyUYIku92LDLxgkLvm/H5K9zzya4nzKNcfeLEszPI2tMtvxnC4c7UaVAYkrLXOGP4bjSHwu105V3+HxA/m84pGOv28DMYsGvySWfrXyZ8rjRM/TD0WUMeovRw8MR+0qTHm1fWRyUrMX/x8AAP//nxVJ3Q==" + return "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" } diff --git a/metricbeat/module/system/socket_summary/_meta/docs.asciidoc b/metricbeat/module/system/socket_summary/_meta/docs.asciidoc new file mode 100644 index 000000000000..6f6bc1418539 --- /dev/null +++ b/metricbeat/module/system/socket_summary/_meta/docs.asciidoc @@ -0,0 +1,20 @@ +The System `socket_summary` metricset provides the summary of open network sockets in the host system. + +The following metrics are exported: +* TCP + * all: All connections + * listening: All listening connections +* UDP: + * all: All connections + +This metricset is available on: + +- FreeBSD +- Linux +- macOS +- Windows + +[float] +=== Configuration + +There are no configuration options for this metricset. diff --git a/metricbeat/module/system/socket_summary/_meta/fields.yml b/metricbeat/module/system/socket_summary/_meta/fields.yml new file mode 100644 index 000000000000..65b78d46907f --- /dev/null +++ b/metricbeat/module/system/socket_summary/_meta/fields.yml @@ -0,0 +1,53 @@ +- name: socket.summary + title: Socket summary + type: group + description: > + Summary metrics of open sockets in the host system + fields: + - name: all + type: group + description: > + All connections + fields: + - name: count + type: integer + description: > + All open connections + - name: listening + type: integer + description: > + All listening ports + - name: tcp + type: group + description: > + All TCP connections + fields: + - name: all + type: group + description: > + All TCP connections + fields: + - name: count + type: integer + description: > + All open TCP connections + - name: listening + type: integer + description: > + All TCP listening ports + - name: udp + type: group + description: > + All UDP connections + fields: + - name: all + type: group + description: > + All UDP connections + fields: + - name: count + type: integer + description: > + All open TCP connections + + diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go new file mode 100644 index 000000000000..a1d13a75862f --- /dev/null +++ b/metricbeat/module/system/socket_summary/socket_summary.go @@ -0,0 +1,119 @@ +// 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. + +package socket_summary + +import ( + "syscall" + + "github.com/elastic/beats/libbeat/common" + + "github.com/elastic/beats/libbeat/common/cfgwarn" + "github.com/elastic/beats/metricbeat/mb" + + "github.com/shirou/gopsutil/net" +) + +// 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 +// MetricSet has been created then Fetch will begin to be called periodically. +func init() { + mb.Registry.MustAddMetricSet("system", "socket_summary", New, + mb.WithNamespace("system.socket.summary"), + ) +} + +// MetricSet holds any configuration or state information. It must implement +// the mb.MetricSet interface. And this is best achieved by embedding +// mb.BaseMetricSet because it implements all of the required mb.MetricSet +// interface methods except for Fetch. +type MetricSet struct { + mb.BaseMetricSet +} + +// 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) { + cfgwarn.Experimental("The socket_summary metricset is experimental.") + + return &MetricSet{ + BaseMetricSet: base, + }, nil +} + +func calculateConnStats(conns []net.ConnectionStat) common.MapStr { + var ( + allConns = len(conns) + allListening = 0 + tcpConns = 0 + tcpListening = 0 + udpConns = 0 + ) + + for _, conn := range conns { + if conn.Status == "LISTEN" { + allListening++ + } + switch conn.Type { + case syscall.SOCK_STREAM: + tcpConns++ + + if conn.Status == "LISTEN" { + tcpListening++ + } + case syscall.SOCK_DGRAM: + udpConns++ + } + } + + return common.MapStr{ + "all": common.MapStr{ + "count": allConns, + "listening": allListening, + }, + "tcp": common.MapStr{ + "all": common.MapStr{ + "count": tcpConns, + "listening": tcpListening, + }, + }, + "udp": common.MapStr{ + "all": common.MapStr{ + "count": udpConns, + }, + }, + } +} + +// 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) { + + // all network connections + conns, err := net.Connections("inet") + + if err != nil { + report.Error(err) + return + } + + report.Event(mb.Event{ + MetricSetFields: calculateConnStats(conns), + }) +} diff --git a/metricbeat/module/system/socket_summary/socket_summary_test.go b/metricbeat/module/system/socket_summary/socket_summary_test.go new file mode 100644 index 000000000000..22f97df283eb --- /dev/null +++ b/metricbeat/module/system/socket_summary/socket_summary_test.go @@ -0,0 +1,107 @@ +// 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. + +package socket_summary + +import ( + "syscall" + "testing" + + "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", + }, + } +} + +func TestCalculateConnStats(t *testing.T) { + conns := getMockedConns() + metrics := calculateConnStats(conns) + + allConns, err := metrics.GetValue("all.count") + + if err != nil { + t.Fail() + } + + allListens, err := metrics.GetValue("all.listening") + + if err != nil { + t.Fail() + } + + udpConns, err := metrics.GetValue("udp.all.count") + + if err != nil { + t.Fail() + } + + tcpConns, err := metrics.GetValue("tcp.all.count") + + if err != nil { + t.Fail() + } + + tcpListens, err := metrics.GetValue("tcp.all.listening") + + 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) +} diff --git a/metricbeat/tests/system/test_system.py b/metricbeat/tests/system/test_system.py index d5f01eb87880..35cfcf00cc79 100644 --- a/metricbeat/tests/system/test_system.py +++ b/metricbeat/tests/system/test_system.py @@ -449,6 +449,40 @@ def test_process_metricbeat(self): assert isinstance(output["system.process.cpu.start_time"], six.string_types) self.check_username(output["system.process.username"]) + @unittest.skipUnless(re.match("(?i)win|linux|darwin|freebsd", sys.platform), "os") + def test_socket_summary(self): + """ + Test system/socket_summary output. + """ + self.render_config_template(modules=[{ + "name": "system", + "metricsets": ["socket_summary"], + "period": "5s", + }]) + proc = self.start_beat() + self.wait_until(lambda: self.output_lines() > 0) + proc.check_kill_and_wait() + self.assert_no_logged_warnings() + + output = self.read_output_json() + self.assertGreater(len(output), 0) + + for evt in output: + self.assert_fields_are_documented(evt) + + summary = evt["system"]["socket"]["summary"] + a = summary["all"] + tcp = summary["tcp"] + udp = summary["udp"] + + assert isinstance(a["count"], int) + assert isinstance(a["listening"], int) + + assert isinstance(tcp["all"]["count"], int) + assert isinstance(tcp["all"]["listening"], int) + + assert isinstance(udp["all"]["count"], int) + def check_username(self, observed, expected=None): if expected == None: expected = getpass.getuser()