diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc index e20536f3e6fc..3e4893966cd2 100644 --- a/CHANGELOG.asciidoc +++ b/CHANGELOG.asciidoc @@ -129,6 +129,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha1...master[Check the HEAD d *Journalbeat* *Metricbeat* +- event.duration is now in nano and not microseconds anymore. {pull}8941[8941] *Packetbeat* diff --git a/dev-tools/ecs-migration.yml b/dev-tools/ecs-migration.yml index ed5bf9709d4c..869f8e655302 100644 --- a/dev-tools/ecs-migration.yml +++ b/dev-tools/ecs-migration.yml @@ -375,7 +375,6 @@ - from: nginx.access.method to: http.request.method alias: true - copy_to: false - from: nginx.access.http_version to: http.version @@ -413,3 +412,29 @@ - from: source.hostname to: source.domain alias: true + +# Metricbeat base fields +- from: metricset.name + to: event.dataset + alias: false + comment: Data structure of field changed, old field will stay around + breaking: true + +- from: metricset.module + to: event.module + alias: true + +- from: metricset.rrt + to: event.duration + alias: false + comment: Unit changed, old field will stay around if needed + breaking: true + +- from: metricset.host + to: service.address + alias: true + +- from: metricset.namespace + to: event.dataset + alias: false + comment: No alias mapping as field did not always exist diff --git a/metricbeat/_meta/fields.common.yml b/metricbeat/_meta/fields.common.yml index c978973b763e..647dfff5b777 100644 --- a/metricbeat/_meta/fields.common.yml +++ b/metricbeat/_meta/fields.common.yml @@ -7,27 +7,18 @@ - name: metricset.module description: > The name of the module that generated the event. + type: alias + path: event.module - name: metricset.name description: > The name of the metricset that generated the event. - - name: metricset.host + - name: service.address description: > - Hostname of the machine from which the metricset was collected. This + Connection address of the machine from which the metricset was collected. This field may not be present when the data was collected locally. - - name: metricset.rtt - type: long - required: true - description: > - Event round trip time in microseconds. - - - name: metricset.namespace - type: keyword - description: > - Namespace of dynamic metricsets. - - name: type required: true example: metricsets diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 6f1dc91cd05d..d2d7e657cd74 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -1781,6 +1781,10 @@ Contains common fields available in all event types. *`metricset.module`*:: + -- +type: alias + +alias to: event.module + The name of the module that generated the event. @@ -1794,32 +1798,10 @@ The name of the metricset that generated the event. -- -*`metricset.host`*:: +*`service.address`*:: + -- -Hostname of the machine from which the metricset was collected. This field may not be present when the data was collected locally. - - --- - -*`metricset.rtt`*:: -+ --- -type: long - -required: True - -Event round trip time in microseconds. - - --- - -*`metricset.namespace`*:: -+ --- -type: keyword - -Namespace of dynamic metricsets. +Connection address of the machine from which the metricset was collected. This field may not be present when the data was collected locally. -- diff --git a/metricbeat/include/fields.go b/metricbeat/include/fields.go index 5c1b7c57aa2f..febeef30177f 100644 --- a/metricbeat/include/fields.go +++ b/metricbeat/include/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "eJyUkz2O2zAQhXud4mH71QFUBAgWAVKl2gvMkmNzYJKjkCMrun0gxkpiYy3D6ijqvW9+nl5x4mWA05Q0d4CJRR7wtp09V1dkNNE84EsHAG+ajSTXiwgH4egr6EwS6SMyJINiBJ85G2wZufYdLp8NXfN4RabEAxJbEVfZ+qR+itwuP6Wuz3vgpoMeYIHxRwMLZDhy5kLGvt00dn+PtZ6fJG3a52FBq+3Dvmu1Kxi5IJlxKJowB3HhpoaZ1uHHyM7Y93gPUv+atTEj0YKshg/GWLiui5gD5+bjyejaAlEdxbjc7aHY1sK6zgFR8/HyovDPSQr7AVamB1P91hJRdMoeVmSESWpxSeKKVnaafd3dWh3J8VUpJ15mLX4f/GOTriP2S6Yk7p/zLXI13uuOf1Ea4/+11cdp8uqmtP0QPb7GmZaKlijFi1f30ne/AwAA//9Prh2/" + return "eJyUUkuu2zAM3PsUg7ePD6BFgSJXyAUYiamEUpIr0XF9+0KqHDRBm+J5J5Lz4dAnfOfdwOYYc5oADSpscD7ejqstYdGQk8GXCQDOOSmFVAcIt8DiKuhOQegqjJBAIuA7J4XuC9d5whgzU+c4IVFkg8hagq2sc8xuFe7Nv6q27+K545BvUM/4jYF6UnzjxIWUXe907XkAmwUDkkB1VBZSb8bQEP6Hrfb+pKkD+8bXk1jlcg+WZ3KucK3v1c45JbatijH/0CXrQ2LcSo7YfLD+xc5G7WQibJXdjIsP9UHbj4NIO1JWXBlL4drOt3lOnceR0jMFJFsS2V/WaWkP3sI/1lDYGWhZjyL/pLjInyH/Z+UWsMt2jcfvNOOrbLRX9JAzPly2H/P0KwAA//+4AOJo" } diff --git a/metricbeat/include/fields/fields.go b/metricbeat/include/fields/fields.go index 7d97ed52cf68..4f9df08ea2e7 100644 --- a/metricbeat/include/fields/fields.go +++ b/metricbeat/include/fields/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/metricbeat/mb/event.go b/metricbeat/mb/event.go index 2e43e71ee8f3..6647adfbdf7a 100644 --- a/metricbeat/mb/event.go +++ b/metricbeat/mb/event.go @@ -18,6 +18,7 @@ package mb import ( + "fmt" "time" "github.com/elastic/beats/libbeat/beat" @@ -116,27 +117,32 @@ func (e *Event) BeatEvent(module, metricSet string, modifiers ...EventModifier) // "rtt": 115 // } func AddMetricSetInfo(module, metricset string, event *Event) { - info := common.MapStr{ - "name": metricset, - "module": module, + + if event.Namespace == "" { + event.Namespace = fmt.Sprintf("%s.%s", module, metricset) + } + + e := common.MapStr{ + "event": common.MapStr{ + "dataset": event.Namespace, + "module": module, + }, + // TODO: This should only be sent if migration layer is enabled + "metricset": common.MapStr{ + "name": metricset, + }, } if event.Host != "" { - info["host"] = event.Host + e.Put("service.address", event.Host) } if event.Took > 0 { - info["rtt"] = event.Took / time.Microsecond - } - if event.Namespace != "" { - info["namespace"] = event.Namespace - } - info = common.MapStr{ - "metricset": info, + e.Put("event.duration", event.Took/time.Nanosecond) } if event.RootFields == nil { - event.RootFields = info + event.RootFields = e } else { - event.RootFields.DeepUpdate(info) + event.RootFields.DeepUpdate(e) } } diff --git a/metricbeat/mb/event_test.go b/metricbeat/mb/event_test.go index f6450dbd6c61..433dae3c2a1a 100644 --- a/metricbeat/mb/event_test.go +++ b/metricbeat/mb/event_test.go @@ -186,11 +186,16 @@ func TestAddMetricSetInfo(t *testing.T) { AddMetricSetInfo(moduleName, metricSetName, &e) assert.Equal(t, common.MapStr{ + "event": common.MapStr{ + "module": moduleName, + "dataset": moduleName + "." + metricSetName, + "duration": time.Duration(500000000), + }, + "service": common.MapStr{ + "address": host, + }, "metricset": common.MapStr{ - "host": host, - "module": moduleName, - "name": metricSetName, - "rtt": time.Duration(500000), + "name": metricSetName, }, }, e.RootFields) }) @@ -201,9 +206,12 @@ func TestAddMetricSetInfo(t *testing.T) { AddMetricSetInfo(moduleName, metricSetName, &e) assert.Equal(t, common.MapStr{ + "event": common.MapStr{ + "module": moduleName, + "dataset": moduleName + "." + metricSetName, + }, "metricset": common.MapStr{ - "module": moduleName, - "name": metricSetName, + "name": metricSetName, }, }, e.RootFields) }) diff --git a/metricbeat/mb/module/example_test.go b/metricbeat/mb/module/example_test.go index 806d7c0ff91d..50bf2c9c203c 100644 --- a/metricbeat/mb/module/example_test.go +++ b/metricbeat/mb/module/example_test.go @@ -64,7 +64,7 @@ func ExampleWrapper() { go func() { defer wg.Done() for event := range output { - event.Fields.Put("metricset.rtt", 111) + event.Fields.Put("event.duration", 111) output, err := encodeEvent(event) if err == nil { @@ -90,15 +90,18 @@ func ExampleWrapper() { // "version": "1.2.3" // }, // "@timestamp": "2016-05-10T23:27:58.485Z", + // "event": { + // "dataset": "fake.eventfetcher", + // "duration": 111, + // "module": "fake" + // }, // "fake": { // "eventfetcher": { // "metric": 1 // } // }, // "metricset": { - // "module": "fake", - // "name": "eventfetcher", - // "rtt": 111 + // "name": "eventfetcher" // }, // "service": { // "type": "fake" diff --git a/metricbeat/module/docker/image/_meta/data.json b/metricbeat/module/docker/image/_meta/data.json index d678192f0f1a..632b353f929e 100644 --- a/metricbeat/module/docker/image/_meta/data.json +++ b/metricbeat/module/docker/image/_meta/data.json @@ -1,29 +1,48 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, "docker": { "image": { - "created": "2017-12-07T06:18:10.000Z", + "created": "2018-11-27T14:54:24.000Z", "id": { - "current": "sha256:8af9af305016ff6501ad0605e390e0a3b535265c0d0cf43375ea8149b794d1d3", - "parent": "sha256:d082cc35db8aef622e2a3e659cca62962158e72fbad5c8edd9f664007ae048f1" + "current": "sha256:bd0649cfa954c27054c5b4c67a2091e5d03f41a441e78b6971328cd3936a997f", + "parent": "sha256:a75037d73967907c74a2e5e219ae1eb10e9a35bb055a926eead2920866f75764" + }, + "labels": { + "description": "Filebeat sends log files to Logstash or directly to Elasticsearch.", + "license": "ASL 2.0", + "org_label-schema_build-date": "20181006", + "org_label-schema_license": "GPLv2", + "org_label-schema_name": "filebeat", + "org_label-schema_schema-version": "1.0", + "org_label-schema_url": "https://www.elastic.co/products/beats/filebeat", + "org_label-schema_vcs-ref": "b9806f16b79dce1223119de94251cb1900f45e7f", + "org_label-schema_vcs-url": "github.com/elastic/beats", + "org_label-schema_vendor": "Elastic", + "org_label-schema_version": "7.0.0" }, "size": { - "regular": 799052371, - "virtual": 799052371 + "regular": 280257780, + "virtual": 280257780 }, "tags": [ - "metricbeatsnapshotnoxpack700alpha1d71419298b58ed8b0a5b60a6d1e4a476ffaf80a8_beat:latest" + "docker.elastic.co/beats/filebeat-oss:7.0.0" ] } }, + "event": { + "dataset": "docker.image", + "duration": 115000, + "module": "docker" + }, "metricset": { - "host": "unix:///var/run/docker.sock", - "module": "docker", - "name": "image", - "rtt": 115 + "name": "image" + }, + "service": { + "type": "docker", + "uri": "/var/run/docker.sock" } } \ No newline at end of file diff --git a/metricbeat/module/elasticsearch/index/index.go b/metricbeat/module/elasticsearch/index/index.go index 459311e79666..9e50bc464be9 100644 --- a/metricbeat/module/elasticsearch/index/index.go +++ b/metricbeat/module/elasticsearch/index/index.go @@ -31,6 +31,7 @@ import ( func init() { mb.Registry.MustAddMetricSet(elasticsearch.ModuleName, "index", New, mb.WithHostParser(elasticsearch.HostParser), + mb.WithNamespace("elasticsearch.index"), ) } diff --git a/metricbeat/module/elasticsearch/test_elasticsearch.py b/metricbeat/module/elasticsearch/test_elasticsearch.py index 20cf9d7452f4..587f7993299a 100644 --- a/metricbeat/module/elasticsearch/test_elasticsearch.py +++ b/metricbeat/module/elasticsearch/test_elasticsearch.py @@ -42,7 +42,7 @@ def test_metricsets(self, metricset): es = Elasticsearch(self.get_hosts()) es.indices.create(index='test-index', ignore=400) self.check_metricset("elasticsearch", metricset, self.get_hosts(), self.FIELDS + - ["service.name"], extras={"index_recovery.active_only": "false"}) + ["service"], extras={"index_recovery.active_only": "false"}) def get_hosts(self): return [os.getenv('ES_HOST', 'localhost') + ':' + diff --git a/metricbeat/module/system/core/_meta/data.json b/metricbeat/module/system/core/_meta/data.json index fe926e62ffed..c6ddec8fd03a 100644 --- a/metricbeat/module/system/core/_meta/data.json +++ b/metricbeat/module/system/core/_meta/data.json @@ -1,24 +1,30 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.core", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "core", - "rtt": 115 + "name": "core" + }, + "service": { + "type": "system" }, "system": { "core": { "id": 1, "idle": { - "pct": 0.3333, - "ticks": 51795238 + "pct": 0.2157, + "ticks": 19266526 }, "iowait": { "pct": 0, - "ticks": 42254 + "ticks": 0 }, "irq": { "pct": 0, @@ -26,23 +32,23 @@ }, "nice": { "pct": 0, - "ticks": 15 + "ticks": 0 }, "softirq": { "pct": 0, - "ticks": 1469 + "ticks": 0 }, "steal": { "pct": 0, "ticks": 0 }, "system": { - "pct": 0.25, - "ticks": 109372 + "pct": 0.3137, + "ticks": 781976 }, "user": { - "pct": 0.4167, - "ticks": 185023 + "pct": 0.4706, + "ticks": 566036 } } } diff --git a/metricbeat/module/system/cpu/_meta/data.json b/metricbeat/module/system/cpu/_meta/data.json index 77d23d3f1528..98bf2d2cd7fb 100644 --- a/metricbeat/module/system/cpu/_meta/data.json +++ b/metricbeat/module/system/cpu/_meta/data.json @@ -1,30 +1,36 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.cpu", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "cpu", - "rtt": 115 + "name": "cpu" + }, + "service": { + "type": "system" }, "system": { "cpu": { - "cores": 4, + "cores": 8, "idle": { "norm": { - "pct": 0.4208 + "pct": 0.2085 }, - "pct": 1.6831, - "ticks": 207356495 + "pct": 1.6679, + "ticks": 138292915 }, "iowait": { "norm": { - "pct": 0.0437 + "pct": 0 }, - "pct": 0.1749, - "ticks": 179383 + "pct": 0, + "ticks": 0 }, "irq": { "norm": { @@ -38,14 +44,14 @@ "pct": 0 }, "pct": 0, - "ticks": 46 + "ticks": 0 }, "softirq": { "norm": { "pct": 0 }, "pct": 0, - "ticks": 8835 + "ticks": 0 }, "steal": { "norm": { @@ -56,23 +62,23 @@ }, "system": { "norm": { - "pct": 0.1749 + "pct": 0.3283 }, - "pct": 0.6995, - "ticks": 428558 + "pct": 2.6267, + "ticks": 16415782 }, "total": { "norm": { - "pct": 0.5792 + "pct": 0.7915 }, - "pct": 2.3169 + "pct": 6.3321 }, "user": { "norm": { - "pct": 0.3607 + "pct": 0.4632 }, - "pct": 1.4426, - "ticks": 725183 + "pct": 3.7054, + "ticks": 10208630 } } } diff --git a/metricbeat/module/system/diskio/_meta/data.json b/metricbeat/module/system/diskio/_meta/data.json index 0a415a2399f0..5fd372d37a2d 100644 --- a/metricbeat/module/system/diskio/_meta/data.json +++ b/metricbeat/module/system/diskio/_meta/data.json @@ -1,60 +1,35 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.diskio", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "diskio", - "rtt": 115 + "name": "diskio" + }, + "service": { + "type": "system" }, "system": { "diskio": { "io": { - "time": 338930 - }, - "iostat": { - "await": 0, - "busy": 0, - "queue": { - "avg_size": 0 - }, - "read": { - "per_sec": { - "bytes": 0 - }, - "request": { - "merges_per_sec": 0, - "per_sec": 0 - }, - "await": 0 - }, - "request": { - "avg_size": 0 - }, - "service_time": 0, - "write": { - "per_sec": { - "bytes": 0 - }, - "request": { - "merges_per_sec": 0, - "per_sec": 0 - }, - "await": 0 - } + "time": 18566027 }, - "name": "sda", + "name": "disk0", "read": { - "bytes": 2540010496, - "count": 128537, - "time": 166380 + "bytes": 1107819708416, + "count": 23921292, + "time": 14179708 }, "write": { - "bytes": 110828974080, - "count": 374728, - "time": 2139780 + "bytes": 468146114560, + "count": 26997360, + "time": 4386319 } } } diff --git a/metricbeat/module/system/filesystem/_meta/data.json b/metricbeat/module/system/filesystem/_meta/data.json index 2d75af1274c0..20723d6f918c 100644 --- a/metricbeat/module/system/filesystem/_meta/data.json +++ b/metricbeat/module/system/filesystem/_meta/data.json @@ -1,27 +1,33 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.filesystem", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "filesystem", - "rtt": 115 + "name": "filesystem" + }, + "service": { + "type": "system" }, "system": { "filesystem": { - "available": 50085941248, - "device_name": "overlay", - "files": 4194304, - "free": 53538639872, - "free_files": 3862303, - "mount_point": "/", - "total": 67371577344, - "type": "overlay", + "available": 0, + "device_name": "devfs", + "files": 1188, + "free": 0, + "free_files": 0, + "mount_point": "/dev", + "total": 351232, + "type": "devfs", "used": { - "bytes": 13832937472, - "pct": 0.2053 + "bytes": 351232, + "pct": 1 } } } diff --git a/metricbeat/module/system/fsstat/_meta/data.json b/metricbeat/module/system/fsstat/_meta/data.json index 136dee4948e9..08bb9cd2a04e 100644 --- a/metricbeat/module/system/fsstat/_meta/data.json +++ b/metricbeat/module/system/fsstat/_meta/data.json @@ -1,22 +1,28 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.fsstat", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "fsstat", - "rtt": 115 + "name": "fsstat" + }, + "service": { + "type": "system" }, "system": { "fsstat": { - "count": 37, - "total_files": 4315786607, + "count": 10, + "total_files": 9309815548, "total_size": { - "free": 58327575072768, - "total": 128010997239808, - "used": 69683422167040 + "free": 3753574465536, + "total": 7896767908864, + "used": 4143193443328 } } } diff --git a/metricbeat/module/system/load/_meta/data.json b/metricbeat/module/system/load/_meta/data.json index 8a4f39be7c4f..770ee76d095e 100644 --- a/metricbeat/module/system/load/_meta/data.json +++ b/metricbeat/module/system/load/_meta/data.json @@ -1,24 +1,30 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.load", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "load", - "rtt": 115 + "name": "load" + }, + "service": { + "type": "system" }, "system": { "load": { - "1": 3.0513, - "15": 2.686, - "5": 2.8188, - "cores": 4, + "1": 3.771, + "15": 3.1479, + "5": 3.4736, + "cores": 8, "norm": { - "1": 0.7628, - "15": 0.6715, - "5": 0.7047 + "1": 0.4714, + "15": 0.3935, + "5": 0.4342 } } } diff --git a/metricbeat/module/system/memory/_meta/data.json b/metricbeat/module/system/memory/_meta/data.json index ba4e77eaac5c..233c98d49c5d 100644 --- a/metricbeat/module/system/memory/_meta/data.json +++ b/metricbeat/module/system/memory/_meta/data.json @@ -1,36 +1,42 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.memory", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "memory", - "rtt": 115 + "name": "memory" + }, + "service": { + "type": "system" }, "system": { "memory": { "actual": { - "free": 1311326208, + "free": 5384859648, "used": { - "bytes": 2827796480, - "pct": 0.6832 + "bytes": 11795009536, + "pct": 0.6866 } }, - "free": 588627968, + "free": 941989888, "swap": { - "free": 23846912, - "total": 1073737728, + "free": 1152122880, + "total": 3221225472, "used": { - "bytes": 1049890816, - "pct": 0.9778 + "bytes": 2069102592, + "pct": 0.6423 } }, - "total": 4139122688, + "total": 17179869184, "used": { - "bytes": 3550494720, - "pct": 0.8578 + "bytes": 16237879296, + "pct": 0.9452 } } } diff --git a/metricbeat/module/system/network/_meta/data.json b/metricbeat/module/system/network/_meta/data.json index 324480d6b05a..d632dfcde08e 100644 --- a/metricbeat/module/system/network/_meta/data.json +++ b/metricbeat/module/system/network/_meta/data.json @@ -1,28 +1,34 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.network", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "network", - "rtt": 115 + "name": "network" + }, + "service": { + "type": "system" }, "system": { "network": { "in": { - "bytes": 34293500, + "bytes": 579535592, "dropped": 0, "errors": 0, - "packets": 303805 + "packets": 3058624 }, "name": "lo0", "out": { - "bytes": 34293500, + "bytes": 579535592, "dropped": 0, "errors": 0, - "packets": 303805 + "packets": 3058624 } } } diff --git a/metricbeat/module/system/process/_meta/data.json b/metricbeat/module/system/process/_meta/data.json index 012d0c3069e8..b3a17471f2e8 100644 --- a/metricbeat/module/system/process/_meta/data.json +++ b/metricbeat/module/system/process/_meta/data.json @@ -1,198 +1,46 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.process", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "process", - "rtt": 115 + "name": "process" + }, + "service": { + "type": "system" }, "system": { "process": { - "cgroup": { - "blkio": { - "id": "d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "path": "/docker/d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "total": { - "bytes": 0, - "ios": 0 - } - }, - "cpu": { - "cfs": { - "period": { - "us": 0 - }, - "quota": { - "us": 0 - }, - "shares": 0 - }, - "id": "d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "path": "/docker/d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "rt": { - "period": { - "us": 0 - }, - "runtime": { - "us": 0 - } - }, - "stats": { - "periods": 0, - "throttled": { - "ns": 0, - "periods": 0 - } - } - }, - "cpuacct": { - "id": "d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "path": "/docker/d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "percpu": {}, - "stats": { - "system": { - "ns": 0 - }, - "user": { - "ns": 0 - } - }, - "total": { - "ns": 0 - } - }, - "id": "d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "memory": { - "id": "d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "kmem": { - "failures": 0, - "limit": { - "bytes": 0 - }, - "usage": { - "bytes": 0, - "max": { - "bytes": 0 - } - } - }, - "kmem_tcp": { - "failures": 0, - "limit": { - "bytes": 0 - }, - "usage": { - "bytes": 0, - "max": { - "bytes": 0 - } - } - }, - "mem": { - "failures": 0, - "limit": { - "bytes": 0 - }, - "usage": { - "bytes": 0, - "max": { - "bytes": 0 - } - } - }, - "memsw": { - "failures": 0, - "limit": { - "bytes": 0 - }, - "usage": { - "bytes": 0, - "max": { - "bytes": 0 - } - } - }, - "path": "/docker/d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e", - "stats": { - "active_anon": { - "bytes": 0 - }, - "active_file": { - "bytes": 0 - }, - "cache": { - "bytes": 0 - }, - "hierarchical_memory_limit": { - "bytes": 0 - }, - "hierarchical_memsw_limit": { - "bytes": 0 - }, - "inactive_anon": { - "bytes": 0 - }, - "inactive_file": { - "bytes": 0 - }, - "major_page_faults": 0, - "mapped_file": { - "bytes": 0 - }, - "page_faults": 0, - "pages_in": 0, - "pages_out": 0, - "rss": { - "bytes": 0 - }, - "rss_huge": { - "bytes": 0 - }, - "swap": { - "bytes": 0 - }, - "unevictable": { - "bytes": 0 - } - } - }, - "path": "/docker/d88e67bb6961a5bb70c1c1c48094c6030e43768eed91e827f437111888f9967e" - }, - "cmdline": "go test -tags=integration github.com/elastic/beats/metricbeat/module/... -data", "cpu": { - "start_time": "2017-12-07T07:20:59.000Z", + "start_time": "2018-12-12T08:05:53.748Z", "total": { "norm": { - "pct": 0.0099 + "pct": 0 }, - "pct": 0.0397 + "pct": 0, + "value": 60 } }, - "cwd": "/go/src/github.com/elastic/beats/metricbeat", - "fd": { - "limit": { - "hard": 1048576, - "soft": 1048576 - }, - "open": 8 - }, "memory": { "rss": { - "bytes": 14540800, - "pct": 0.0035 + "bytes": 0, + "pct": 0 }, "share": 0, - "size": 402231296 + "size": 8192 }, "name": "go", - "pgid": 1, - "pid": 1, - "ppid": 0, - "state": "sleeping", - "username": "root" + "pgid": 53737, + "pid": 53883, + "ppid": 53737, + "state": "running", + "username": "ruflin" } } } \ No newline at end of file diff --git a/metricbeat/module/system/process_summary/_meta/data.json b/metricbeat/module/system/process_summary/_meta/data.json index 876e16584520..8eadab84b0fe 100644 --- a/metricbeat/module/system/process_summary/_meta/data.json +++ b/metricbeat/module/system/process_summary/_meta/data.json @@ -1,24 +1,30 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.process.summary", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "process_summary", - "namespace": "system.process.summary", - "rtt": 115 + "name": "process_summary" + }, + "service": { + "type": "system" }, "system": { "process": { "summary": { + "dead": 0, "idle": 0, - "running": 2, - "sleeping": 2, + "running": 308, + "sleeping": 0, "stopped": 0, - "total": 4, - "unknown": 0, + "total": 487, + "unknown": 179, "zombie": 0 } } diff --git a/metricbeat/module/system/raid/_meta/data.json b/metricbeat/module/system/raid/_meta/data.json index b0ea391ccf57..c3ced10ba019 100644 --- a/metricbeat/module/system/raid/_meta/data.json +++ b/metricbeat/module/system/raid/_meta/data.json @@ -1,13 +1,19 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.raid", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "raid", - "rtt": 115 + "name": "raid" + }, + "service": { + "type": "system" }, "system": { "raid": { diff --git a/metricbeat/module/system/uptime/_meta/data.json b/metricbeat/module/system/uptime/_meta/data.json index 2e499970235f..cef570d40bc3 100644 --- a/metricbeat/module/system/uptime/_meta/data.json +++ b/metricbeat/module/system/uptime/_meta/data.json @@ -1,18 +1,24 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { + "agent": { "hostname": "host.example.com", "name": "host.example.com" }, + "event": { + "dataset": "system.uptime", + "duration": 115000, + "module": "system" + }, "metricset": { - "module": "system", - "name": "uptime", - "rtt": 115 + "name": "uptime" + }, + "service": { + "type": "system" }, "system": { "uptime": { "duration": { - "ms": 522806000 + "ms": 386456130 } } } diff --git a/metricbeat/tests/system/metricbeat.py b/metricbeat/tests/system/metricbeat.py index 5b81dd78893f..e4182d44f775 100644 --- a/metricbeat/tests/system/metricbeat.py +++ b/metricbeat/tests/system/metricbeat.py @@ -7,7 +7,7 @@ from beat.beat import TestCase COMMON_FIELDS = ["@timestamp", "agent", "metricset.name", "metricset.host", - "metricset.module", "metricset.rtt", "host.name", "service.name"] + "metricset.module", "metricset.rtt", "host.name", "service.name", "event"] INTEGRATION_TESTS = os.environ.get('INTEGRATION_TESTS', False) @@ -85,11 +85,13 @@ def check_metricset(self, module, metricset, hosts, fields=[], extras=[]): self.assert_no_logged_warnings() output = self.read_output_json() + print output self.assertTrue(len(output) >= 1) evt = output[0] print(evt) fields = COMMON_FIELDS + fields + print fields self.assertItemsEqual(self.de_dot(fields), evt.keys()) self.assert_fields_are_documented(evt) diff --git a/metricbeat/tests/system/test_processors.py b/metricbeat/tests/system/test_processors.py index 93b46ab41285..e4067eb8825a 100644 --- a/metricbeat/tests/system/test_processors.py +++ b/metricbeat/tests/system/test_processors.py @@ -34,8 +34,7 @@ def test_drop_fields(self): print(evt) print(evt.keys()) self.assertItemsEqual(self.de_dot([ - 'agent', '@timestamp', 'system', 'metricset.module', - 'metricset.rtt', 'metricset.name', 'host', 'service' + 'agent', '@timestamp', 'system', 'host', 'event', 'service', 'metricset' ]), evt.keys()) cpu = evt["system"]["cpu"] print(cpu.keys()) @@ -270,7 +269,7 @@ def test_rename_field(self): }], processors=[{ "rename": { - "fields": [{"from": "metricset.name", "to": "hello.world"}], + "fields": [{"from": "event.dataset", "to": "hello.world"}], }, }] ) @@ -285,5 +284,5 @@ def test_rename_field(self): print(evt) print(evt.keys()) - assert "name" not in output[0]["metricset"] + assert "dataset" not in output[0]["event"] assert "cpu" in output[0]["hello"]["world"] diff --git a/metricbeat/tests/system/test_redis.py b/metricbeat/tests/system/test_redis.py index daf156a1c1ad..d57a88465ba0 100644 --- a/metricbeat/tests/system/test_redis.py +++ b/metricbeat/tests/system/test_redis.py @@ -92,7 +92,7 @@ def test_module_processors(self): Test local processors for Redis info event. """ fields = ["clients", "cpu"] - eventFields = ['beat', 'metricset', 'service'] + eventFields = ['beat', 'metricset', 'service', 'event'] eventFields += ['redis.info.' + f for f in fields] self.render_config_template(modules=[{ "name": "redis", diff --git a/metricbeat/tests/system/test_template.py b/metricbeat/tests/system/test_template.py index 0f6e09b8dcb8..5ed36b0072dd 100644 --- a/metricbeat/tests/system/test_template.py +++ b/metricbeat/tests/system/test_template.py @@ -49,7 +49,7 @@ def test_export_template(self): assert properties["host"]["properties"]["name"] == {"type": "keyword", "ignore_above": 1024} # Check metricbeat generic field - assert properties["metricset"]["properties"]["host"] == {"type": "keyword", "ignore_above": 1024} + assert properties["service"]["properties"]["address"] == {"type": "keyword", "ignore_above": 1024} # Check module specific field assert properties["system"]["properties"]["cpu"]["properties"]["cores"] == {"type": "long"}