diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index ebc748e47433..0b812bf59319 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -6681,12 +6681,12 @@ Kibana stats and run-time metrics. -*`kibana.stats.cluster_uuid`*:: +*`kibana.stats.uuid`*:: + -- type: keyword -UUID of the Elasticsearch cluster to which Kibana connects. +Kibana instance UUID -- @@ -6694,246 +6694,203 @@ UUID of the Elasticsearch cluster to which Kibana connects. *`kibana.stats.name`*:: + -- -type: keyword +type: text -Kibana instance name. +Kibana instance name -- -*`kibana.stats.uuid`*:: +*`kibana.stats.index`*:: + -- type: keyword -Kibana instance uuid. +Name of Kibana's internal index -- -*`kibana.stats.version.number`*:: +*`kibana.stats.host.name`*:: + -- type: keyword -Kibana version number. +Kibana instance hostname -- -*`kibana.stats.status.overall.state`*:: +*`kibana.stats.transport_address`*:: + -- type: keyword -Kibana overall state. +Kibana server's hostname and port -- -[float] -== process fields - -Kibana process metrics. - - - -[float] -== mem fields - -Memory usage metrics of the Kibana instance. - - - -*`kibana.stats.process.mem.heap.max.bytes`*:: +*`kibana.stats.version`*:: + -- -type: long - -format: bytes +type: keyword -Total amount of heap memory used by V8. +Kibana version -- -*`kibana.stats.process.mem.heap.used.bytes`*:: +*`kibana.stats.snapshot`*:: + -- -type: long - -format: bytes +type: boolean -Amount of memory in use by V8. +Whether the Kibana build is a snapshot build -- -*`kibana.stats.process.mem.resident_set_size.bytes`*:: +*`kibana.stats.status`*:: + -- -type: long - -format: bytes +type: keyword -The amount of space occupied in main memory for the process. Includes heap, code segment, and stack. +Kibana instance's health status -- -*`kibana.stats.process.mem.external.bytes`*:: +*`kibana.stats.concurrent_connections`*:: + -- type: long -format: bytes - -Memory usage of C++ objects bound to JavaScript objects managed by V8. +Number of client connections made to the server. Note that browsers can send multiple simultaneous connections to request mulitple server assets at once, and they can re-use established connections. -- -*`kibana.stats.process.pid`*:: -+ --- -type: long +[float] +== process fields -Process ID of the Kibana instance. +Process metrics --- -*`kibana.stats.process.uptime.ms`*:: +*`kibana.stats.process.event_loop_delay.ms`*:: + -- -type: long +type: scaled_float -Amount of time that the Kibana process has been running in milliseconds. +Event loop delay in milliseconds -- [float] -== response_times fields +== memory.heap fields -HTTP Server response time metrics +Process heap metrics -*`kibana.stats.response_times.avg.ms`*:: +*`kibana.stats.process.memory.heap.total.bytes`*:: + -- type: long -Accumulated averages for response times, for all responses in a 5-second time window. +format: bytes + +Total heap allocated to process in bytes -- -*`kibana.stats.response_times.max.ms`*:: +*`kibana.stats.process.memory.heap.used.bytes`*:: + -- type: long -Accumulated maximums for response times, for all responses in a 5-second time window. - - --- - -[float] -== requests fields - -HTTP Server request metrics - - - -*`kibana.stats.requests.status_codes`*:: -+ --- -type: object +format: bytes -Key-value pairs for each status code sent by the server, and the number of times it sent that code. +Heap used by process in bytes -- -*`kibana.stats.requests.total`*:: +*`kibana.stats.process.memory.heap.size_limit.bytes`*:: + -- type: long -Total number of requests sent by the server. - - --- - -*`kibana.stats.requests.disconnects`*:: -+ --- -type: long +format: bytes -Total number of client disconnects encountered by the server. +Max. old space size allocated to Node.js process, in bytes -- -*`kibana.stats.concurrent_connections`*:: +*`kibana.stats.process.memory.heap.uptime.ms`*:: + -- type: long -Number of client connections made to the server. Note that browsers can send multiple simultaneous connections to request multiple server assets at once, and they can re-use established connections. +Uptime of process in milliseconds -- [float] -== sockets fields +== request fields -HTTP Web Sockets metrics +Request count metrics -[float] -== http fields +*`kibana.stats.request.disconnects`*:: ++ +-- +type: long -Web Sockets over plaintext HTTP +Number of requests that were disconnected +-- -*`kibana.stats.sockets.http.total`*:: +*`kibana.stats.request.total`*:: + -- type: long -Number of HTTP web socket connections established +Total number of requests -- [float] -== https fields +== response_time fields -Web Sockets over encrypted HTTPS +Response times metrics -*`kibana.stats.sockets.https.total`*:: +*`kibana.stats.response_time.avg.ms`*:: + -- type: long -Number of HTTPS web socket connections established +Average response time in milliseconds -- -*`kibana.stats.event_loop_delay`*:: +*`kibana.stats.response_time.max.ms`*:: + -- type: long -Node event loop delay calculated with internal benchmarking. +Maximum response time in milliseconds -- diff --git a/metricbeat/docs/modules/kibana.asciidoc b/metricbeat/docs/modules/kibana.asciidoc index 14bd52bc9cca..0aa7ce4c2425 100644 --- a/metricbeat/docs/modules/kibana.asciidoc +++ b/metricbeat/docs/modules/kibana.asciidoc @@ -25,6 +25,7 @@ metricbeat.modules: metricsets: ["status"] period: 10s hosts: ["localhost:5601"] + basepath: "" enabled: true ---- diff --git a/metricbeat/helper/xpack/xpack.go b/metricbeat/helper/xpack/xpack.go index 4c7363c8f405..f876be3d8262 100644 --- a/metricbeat/helper/xpack/xpack.go +++ b/metricbeat/helper/xpack/xpack.go @@ -19,7 +19,6 @@ package xpack import ( "fmt" - "time" ) // Product supported by X-Pack Monitoring @@ -57,8 +56,7 @@ func (p Product) String() string { // MakeMonitoringIndexName method returns the name of the monitoring index for // a given product { elasticsearch, kibana, logstash, beats } func MakeMonitoringIndexName(product Product) string { - today := time.Now().UTC().Format("2006.01.02") const version = "6" - return fmt.Sprintf(".monitoring-%v-%v-mb-%v", product, version, today) + return fmt.Sprintf(".monitoring-%v-%v-mb", product, version) } diff --git a/metricbeat/helper/xpack/xpack_test.go b/metricbeat/helper/xpack/xpack_test.go index 841e6730c666..c6aa2cd5f1fe 100644 --- a/metricbeat/helper/xpack/xpack_test.go +++ b/metricbeat/helper/xpack/xpack_test.go @@ -20,14 +20,11 @@ package xpack import ( "fmt" "testing" - "time" "github.com/stretchr/testify/assert" ) func TestMakeMonitoringIndexName(t *testing.T) { - today := time.Now().UTC().Format("2006.01.02") - tests := []struct { Name string Product Product @@ -36,22 +33,22 @@ func TestMakeMonitoringIndexName(t *testing.T) { { "Elasticsearch monitoring index", Elasticsearch, - fmt.Sprintf(".monitoring-es-6-mb-%v", today), + ".monitoring-es-6-mb", }, { "Kibana monitoring index", Kibana, - fmt.Sprintf(".monitoring-kibana-6-mb-%v", today), + ".monitoring-kibana-6-mb", }, { "Logstash monitoring index", Logstash, - fmt.Sprintf(".monitoring-logstash-6-mb-%v", today), + ".monitoring-logstash-6-mb", }, { "Beats monitoring index", Beats, - fmt.Sprintf(".monitoring-beats-6-mb-%v", today), + ".monitoring-beats-6-mb", }, } diff --git a/metricbeat/mb/parse/url.go b/metricbeat/mb/parse/url.go index af3eb172640d..c3d719368778 100644 --- a/metricbeat/mb/parse/url.go +++ b/metricbeat/mb/parse/url.go @@ -21,6 +21,7 @@ import ( "fmt" "net" "net/url" + p "path" "strings" "github.com/elastic/beats/metricbeat/mb" @@ -31,12 +32,13 @@ import ( // URLHostParserBuilder builds a tailored HostParser for used with host strings // that are URLs. type URLHostParserBuilder struct { - PathConfigKey string - DefaultPath string - DefaultUsername string - DefaultPassword string - DefaultScheme string - QueryParams string + BasePathConfigKey string + PathConfigKey string + DefaultPath string + DefaultUsername string + DefaultPassword string + DefaultScheme string + QueryParams string } // Build returns a new HostParser function whose behavior is influenced by the @@ -49,7 +51,7 @@ func (b URLHostParserBuilder) Build() mb.HostParser { return mb.HostData{}, err } - var user, pass, path string + var user, pass, path, basePath string t, ok := conf["username"] if ok { user, ok = t.(string) @@ -77,8 +79,23 @@ func (b URLHostParserBuilder) Build() mb.HostParser { } else { path = b.DefaultPath } + // Normalize path + path = strings.Trim(path, "/") - return ParseURL(host, b.DefaultScheme, user, pass, path, b.QueryParams) + t, ok = conf[b.BasePathConfigKey] + if ok { + basePath, ok = t.(string) + if !ok { + return mb.HostData{}, errors.Errorf("'%v' config for module %v is not a string", b.BasePathConfigKey, module.Name()) + } + } + // Normalize basepath + basePath = strings.Trim(basePath, "/") + + // Combine paths and normalize + fullPath := strings.Trim(p.Join(basePath, path), "/") + + return ParseURL(host, b.DefaultScheme, user, pass, fullPath, b.QueryParams) } } diff --git a/metricbeat/mb/parse/url_test.go b/metricbeat/mb/parse/url_test.go index 4f08aa236973..3d4fede58ffe 100644 --- a/metricbeat/mb/parse/url_test.go +++ b/metricbeat/mb/parse/url_test.go @@ -114,6 +114,10 @@ func TestURLHostParserBuilder(t *testing.T) { {map[string]interface{}{}, URLHostParserBuilder{DefaultPath: "/default"}, "http://example.com/default"}, {map[string]interface{}{"username": "guest"}, URLHostParserBuilder{}, "http://guest@example.com"}, {map[string]interface{}{"username": "guest", "password": "secret"}, URLHostParserBuilder{}, "http://guest:secret@example.com"}, + {map[string]interface{}{"basepath": "/foo"}, URLHostParserBuilder{BasePathConfigKey: "basepath", DefaultPath: "/default"}, "http://example.com/foo/default"}, + {map[string]interface{}{"basepath": "foo/"}, URLHostParserBuilder{BasePathConfigKey: "basepath", DefaultPath: "/default"}, "http://example.com/foo/default"}, + {map[string]interface{}{"basepath": "/foo/"}, URLHostParserBuilder{BasePathConfigKey: "basepath", DefaultPath: "/default"}, "http://example.com/foo/default"}, + {map[string]interface{}{"basepath": "foo"}, URLHostParserBuilder{BasePathConfigKey: "basepath", DefaultPath: "/default"}, "http://example.com/foo/default"}, } for _, test := range cases { diff --git a/metricbeat/metricbeat.reference.yml b/metricbeat/metricbeat.reference.yml index d9f84bdd57a3..4acd3a0ffb30 100644 --- a/metricbeat/metricbeat.reference.yml +++ b/metricbeat/metricbeat.reference.yml @@ -351,6 +351,7 @@ metricbeat.modules: metricsets: ["status"] period: 10s hosts: ["localhost:5601"] + basepath: "" enabled: true #----------------------------- Kubernetes Module ----------------------------- diff --git a/metricbeat/module/kibana/_meta/config.reference.yml b/metricbeat/module/kibana/_meta/config.reference.yml index 05d0b4d3dbd1..328a5e0b57ac 100644 --- a/metricbeat/module/kibana/_meta/config.reference.yml +++ b/metricbeat/module/kibana/_meta/config.reference.yml @@ -2,4 +2,5 @@ metricsets: ["status"] period: 10s hosts: ["localhost:5601"] + basepath: "" enabled: true diff --git a/metricbeat/module/kibana/_meta/config.yml b/metricbeat/module/kibana/_meta/config.yml index 838670f8b629..f997985d3c2c 100644 --- a/metricbeat/module/kibana/_meta/config.yml +++ b/metricbeat/module/kibana/_meta/config.yml @@ -3,5 +3,6 @@ # - status period: 10s hosts: ["localhost:5601"] + #basepath: "" #username: "user" #password: "secret" diff --git a/metricbeat/module/kibana/config.go b/metricbeat/module/kibana/config.go new file mode 100644 index 000000000000..748ba6bb5e31 --- /dev/null +++ b/metricbeat/module/kibana/config.go @@ -0,0 +1,30 @@ +// 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 kibana + +// Config defines the structure for the Kibana module configuration options +type Config struct { + XPackEnabled bool `config:"xpack.enabled"` +} + +// DefaultConfig returns the default configuration for the Kibana module +func DefaultConfig() Config { + return Config{ + XPackEnabled: false, + } +} diff --git a/metricbeat/module/kibana/fields.go b/metricbeat/module/kibana/fields.go index f8c9dec28a08..68bf480e11b0 100644 --- a/metricbeat/module/kibana/fields.go +++ b/metricbeat/module/kibana/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "eJzsWE1v20YQvftXDHyNpVuBQocCRVqgaZAgqJz2UBTCcjkSt9oPdmcoWf31xSwpiaJJWZHpwAHKgxGRmzdvZufj7U5gjbsZrE2mvLoBYMMWZ3D7Pr24vQHIkXQ0JZvgZ/DDDQBA/RFcyCuLNwBUhMgLHfzSrGawVJbkbUSLinAGGbJAEzIbv6IZ/HlLZG//ugFYGrQ5zRLqBLxy2OIiD+9KnMEqhqps3vTwOcVpYxErpsPbPrhByPppXE04oHwOsfITNg7BIUejadpa3vV4/3TZtRlqWxFjXFSVyU8W7MmucbcNsfvtDGV5Pn9+9xOEJXCB8LNVxEYTqqiLvT3gANvC6GLvoQ7eo+YTf44s5e947BqTxhMrrzGh99sdNypdu4Leb3eDkUzwU1+5DOPoDBp4qOH7KUjKVTQNG4zK2qn8HH8LGvRkbGALyhg0EvWa7hbS5YYb1L4qgoGKaZNy6B59O0fqAmLyfEAX4g4qUqtDge/LqJM8XcbnWLeZF6jKqVMP02zH2I3qqSM2+NXAgmWITvEMzoFc4K8894GVBeVC5Vl8FYIS3zoQmEO2g9+/73O345QsfjVe/Xjwp3HFePHmEmciksnR84KQF2T+xVfj1H2BrY2iUmmEoHVVGszFQafkT+3vMsSUtk2hTeGd17bKkdJm3YEOOQLhyqHnuzTZiJVenw8NPjBGr+yrichJwYYlvH3zBkL2twwyyELlc5lzv6qNmie0wzenvFoN5/ah9z2aPk86eAHxT03vO47oJ3vLYR6Woj2mri9sz6V1LJmkb7hQ3Ca379iFIsgQvSghb/wqJZ6x1hDq4PMBARGRyuAJF4I92jD55f7+E8wxbjAeLEBbnX3hWFGb1QvFVuvKVVYx5qBk5q6QUomesKa79E4G8v49SXgVfDepo1s7tzU+D9vhLJHx8uJuOPVgXOVGduOYL/9USPxCmZKwr8yRWpctpH8Oh7juM9cF+T3uJhtlK4RSmVjHF5UuGsv7zu1ZupcUKCW36iYuv2tVuS9kAsP18lTR8r+HM4dFDLxA4tQi40hsv709fgyTyw3tTylfgaK2Rri1jAJ6LS0SYz05hjgfjnbB6ypGkRINhAm+P6N7aD9B+WOXaMsEOJWjTL4WQ/gYuGnqWQxbwkiglZcNyMFVlk1pEcjIP5XHkBLtiMjhWDaHxXU5KSKUwzFD8BoPabhL8BEnIruQWGXWUIF5G3bg5BP0Gkcu/T8wg3mNe2XdF8x9p4pnnznazOQ4BqVVxjM+cGJ+5TFjqJDhEoF2ofg6pmAK8RazZutOMqe19WdjO1zTYwYXvY67UuaXcJ5/M9Gdf2l4D5J9I/3HhlAucrRqN1b7kSGUsEGwIWGDVlY38mBruADJYzkvQIZeF07FtfGrae8tXfWsa7p5PRrrvXvmjdz/d12jMviW7rr6J8PVk+dDc4P0KC3hgnlzkXqAEYTP29pKy+DwiIanJfr5iF3I6bdGa8hemXR7fe1923nRCCM27K6APFo+J3q6fL/GaHkkddvk/gsAAP//Ii6tlQ==" + return "eJzEmM9u4zYQxu9+ikEue9noAXwoULQFWhQJim2DHorCGIljiw1FqpyRY/fpC1KSI8tUrOzKiA5BItnf9+Nw/oi5h2c6ruFZ52hxBSBaDK3h7td4424FoIgLr2vRzq7huxUAQPsQKqcaQysALp2XTeHsVu/WsEXD4a4nQ8i0hpwkSDOJaLvjNfx1x2zu/l4BbDUZxeuoeg8WKxqwhEuONa1h511Td3cSPOc6Qy0WFD7dTclNSrZXt9SoA2gV+Mbei64IKhKvC84GHx+vuL/GdEPCptHq7EEP+UzHF+fHz95AHeBqy4K2IHh6+uXHpG34mbQVOsi3eV5I957aKjost9ZHrAjctvP/xKCtkLdoEkY9QulYssm1LxLyYDEZAvFouQ7Vgkp5Yl6cg8nvyX/iE0fM2mCZBNqTZ+3s4hgp3VNRWqy5dOM0a01z5wzhGOiK6Z8lSUkepKQeIG+0UaAZ8OTX3ksjCUqz/Gb0SRG2g9BImTLqGQpni8Z7srGVWiqCeJrJOLt7Z7E0VU4+lEthNFmBgQVUqAjExfC1+ZPBoxMCKVEg9+6FyTMUaIHJKqgaI7o2BKzDr2jJNXymKA48/dsQS/iwlvjhqAzITKGXCjhb0OeYnlLSMcp7um+YgFgwN5pLUkPZLBm32rtiqpLGnX5GpH5r5fr+PnqeauWvKLQPu2ecqzeKDB6zavz9HowLNKQ2W+NwXAdXCQF+Cj4QfCD6gLZQaWM0U+GsGpv2eBVVzh+zknAck7fiNYOnj1lQngjcVOgGvdEJmiw/Cl1+943Ej9LOVyhrmPry1QUA/BHc2wWgMa5AIRXSuMuuEOG0+mmQM6kPo/85cAcCyI/zkVn/RxujKy0fBv6AhwycUcA1FhSJzuP/6BRl/3C/qM8zNqIO72ep0ruynBm4T1E7tNFBkCcrryfqWuFSHQrgS9dbC9dYeVeneoVSmrvWeotAvc6bbvHcDpMX8jSwpvFcHbWDG5C1hW4v+CZ2jmtnmTZh25favy+dKATR9w2aVzLc726T4t/vyeOOTkuPlFcGzGDE4OE2WA940FVTzcSafK979wHw96jQbcc3nvVue/AI6uk3pNueMYN62rc7BGRtsd3qjNHVchqhTYDMhaQ2Jgt/Lr8FnXo0m9iCdJF/dQt5aOUu0xJmtI5ZBw1YoGZ/aF0GhtNv83A5L6eR0q+ps5j60Rn2SrOM/oPTX1MhhNkDFK7FbyYvJEbWcH6+HVGYMVBvSXoG938AAAD//7lENR0=" } diff --git a/metricbeat/module/kibana/kibana.go b/metricbeat/module/kibana/kibana.go new file mode 100644 index 000000000000..43f1f711a06c --- /dev/null +++ b/metricbeat/module/kibana/kibana.go @@ -0,0 +1,32 @@ +// 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 kibana + +import ( + "fmt" + + "github.com/elastic/beats/metricbeat/mb" +) + +// ReportErrorForMissingField reports and returns an error message for the given +// field being missing in API response received from Kibana +func ReportErrorForMissingField(field string, r mb.ReporterV2) error { + err := fmt.Errorf("Could not find field '%v' in Kibana stats API response", field) + r.Error(err) + return err +} diff --git a/metricbeat/module/kibana/kibana_test.go b/metricbeat/module/kibana/kibana_test.go new file mode 100644 index 000000000000..543aabda2826 --- /dev/null +++ b/metricbeat/module/kibana/kibana_test.go @@ -0,0 +1,52 @@ +// 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 kibana + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/elastic/beats/metricbeat/mb" +) + +type MockReporterV2 struct { + mb.ReporterV2 +} + +func (MockReporterV2) Event(event mb.Event) bool { + return true +} + +var currentErr error // This hack is necessary because the Error method below cannot receive the type *MockReporterV2 + +func (m MockReporterV2) Error(err error) bool { + currentErr = err + return true +} + +func TestReportErrorForMissingField(t *testing.T) { + field := "some.missing.field" + r := MockReporterV2{} + err := ReportErrorForMissingField(field, r) + + expectedError := fmt.Errorf("Could not find field '%v' in Kibana stats API response", field) + assert.Equal(t, expectedError, err) + assert.Equal(t, expectedError, currentErr) +} diff --git a/metricbeat/module/kibana/stats/_meta/data.json b/metricbeat/module/kibana/stats/_meta/data.json index db7040214857..7097d36ba424 100644 --- a/metricbeat/module/kibana/stats/_meta/data.json +++ b/metricbeat/module/kibana/stats/_meta/data.json @@ -6,65 +6,53 @@ }, "elasticsearch": { "cluster": { - "id": "PKEQ1V5kT4yPng_sgiqF9g" + "id": "njqU4EQaTROIDlWPeUMQyw" } }, "kibana": { "stats": { - "concurrent_connections": 17, - "event_loop_delay": 718.5184001922607, - "name": "kibana", + "concurrent_connections": 6, + "host": { + "name": "localhost" + }, + "index": "Shaunaks-MBP-2", + "name": "Shaunaks-MBP-2", "process": { + "event_loop_delay": { + "ms": 0.23628300055861473 + }, "memory": { - "external": { - "bytes": 1969666 - }, "heap": { - "max": { - "bytes": 200028160 + "size_limit": { + "bytes": 1501560832 + }, + "total": { + "bytes": 215003136 }, "used": { - "bytes": 138875320 + "bytes": 185343400 } - }, - "resident_set_size": { - "bytes": 247865344 } }, - "pid": 1, "uptime": { - "ms": 260863 + "ms": 1343714 } }, - "requests": { + "request": { "disconnects": 0, - "total": 91 + "total": 0 }, - "response_times": { - "avg": { - "ms": 1347.2500000000002 - }, + "response_time": { + "avg": {}, "max": { - "ms": 4293 - } - }, - "sockets": { - "http": { - "total": 56 - }, - "https": { - "total": 0 + "ms": 0 } }, - "status": { - "overall": { - "state": "green" - } - }, - "uuid": "b4b34609-03b3-463c-8699-17109e72df70", - "version": { - "number": "7.0.0-alpha1" - } + "snapshot": false, + "status": "green", + "transport_address": "localhost:5601", + "uuid": "5b2de169-2785-441b-ae8c-186a1936b17d", + "version": "7.0.0-alpha1" } }, "metricset": { @@ -73,6 +61,9 @@ "name": "stats", "rtt": 115 }, + "process": { + "pid": 20173 + }, "service": { "name": "kibana" } diff --git a/metricbeat/module/kibana/stats/_meta/fields.yml b/metricbeat/module/kibana/stats/_meta/fields.yml index 6360ae469483..58da702cc9fc 100644 --- a/metricbeat/module/kibana/stats/_meta/fields.yml +++ b/metricbeat/module/kibana/stats/_meta/fields.yml @@ -4,122 +4,98 @@ Kibana stats and run-time metrics. release: beta fields: - - name: cluster_uuid + - name: uuid type: keyword description: > - UUID of the Elasticsearch cluster to which Kibana connects. + Kibana instance UUID - name: name + type: text + description: > + Kibana instance name + - name: index type: keyword description: > - Kibana instance name. - - name: uuid + Name of Kibana's internal index + - name: host.name + type: keyword + description: > + Kibana instance hostname + - name: transport_address type: keyword description: > - Kibana instance uuid. - - name: version.number + Kibana server's hostname and port + - name: version type: keyword description: > - Kibana version number. - - name: status.overall.state + Kibana version + - name: snapshot + type: boolean + description: > + Whether the Kibana build is a snapshot build + - name: status type: keyword description: > - Kibana overall state. + Kibana instance's health status + - name: concurrent_connections + type: long + description: > + Number of client connections made to the server. Note that browsers can send multiple simultaneous connections to request mulitple server assets at once, and they can re-use established connections. - name: process type: group description: > - Kibana process metrics. + Process metrics fields: - - name: mem - type: group - description: > - Memory usage metrics of the Kibana instance. - fields: - - name: heap.max.bytes - type: long - format: bytes - description: > - Total amount of heap memory used by V8. - - name: heap.used.bytes - type: long - format: bytes - description: > - Amount of memory in use by V8. - - name: resident_set_size.bytes - type: long - format: bytes - description: > - The amount of space occupied in main memory for the process. Includes heap, code segment, and stack. - - name: external.bytes - type: long - format: bytes - description: > - Memory usage of C++ objects bound to JavaScript objects managed by V8. - - name: pid + - name: event_loop_delay.ms + type: scaled_float + description: > + Event loop delay in milliseconds + - name: memory.heap + type: group + description: > + Process heap metrics + fields: + - name: total.bytes type: long + format: bytes description: > - Process ID of the Kibana instance. - - name: uptime.ms + Total heap allocated to process in bytes + - name: used.bytes type: long + format: bytes description: > - Amount of time that the Kibana process has been running in milliseconds. - - name: response_times - type: group - description: > - HTTP Server response time metrics - fields: - - name: avg.ms + Heap used by process in bytes + - name: size_limit.bytes type: long + format: bytes description: > - Accumulated averages for response times, for all responses in a 5-second time window. - - name: max.ms + Max. old space size allocated to Node.js process, in bytes + - name: uptime.ms type: long description: > - Accumulated maximums for response times, for all responses in a 5-second time window. - - name: requests + Uptime of process in milliseconds + - name: request type: group description: > - HTTP Server request metrics + Request count metrics fields: - - name: status_codes - type: object - description: > - Key-value pairs for each status code sent by the server, and the number of times it sent that code. - - name: total + - name: disconnects type: long description: > - Total number of requests sent by the server. - - name: disconnects + Number of requests that were disconnected + - name: total type: long description: > - Total number of client disconnects encountered by the server. - - name: concurrent_connections - type: long - description: > - Number of client connections made to the server. Note that browsers can send multiple simultaneous connections to request multiple server assets at once, and they can re-use established connections. - - name: sockets + Total number of requests + - name: response_time type: group description: > - HTTP Web Sockets metrics + Response times metrics fields: - - name: http - type: group + - name: avg.ms + type: long description: > - Web Sockets over plaintext HTTP - fields: - - name: total - type: long - description: > - Number of HTTP web socket connections established - - name: https - type: group + Average response time in milliseconds + - name: max.ms + type: long description: > - Web Sockets over encrypted HTTPS - fields: - - name: total - type: long - description: > - Number of HTTPS web socket connections established - - name: event_loop_delay - type: long - description: > - Node event loop delay calculated with internal benchmarking. + Maximum response time in milliseconds diff --git a/metricbeat/module/kibana/stats/_meta/test/stats.700.json b/metricbeat/module/kibana/stats/_meta/test/stats.700.json index 01ad405e54a6..0f74c8b8dbd9 100644 --- a/metricbeat/module/kibana/stats/_meta/test/stats.700.json +++ b/metricbeat/module/kibana/stats/_meta/test/stats.700.json @@ -1,53 +1,144 @@ { - "cluster_uuid": "G279hqGeSDqjj_OgBq6wUw", - "name": "ruflin", - "uuid": "3a64c6a4-b758-41b4-9564-375ca3165039", - "version": { - "number": "6.4.0" - }, - "status": { - "overall": { - "state": "green" - } - }, - "response_times": { - "avg_in_millis": 401, - "max_in_millis": 411 - }, - "requests": { - "status_codes": {} - }, - "concurrent_connections": 0, - "sockets": { - "http": { - "total": 76 + "kibana":{ + "uuid":"5b2de169-2785-441b-ae8c-186a1936b17d", + "name":"Shaunaks-MBP-2", + "index":".kibana", + "host":"localhost", + "transport_address":"localhost:5601", + "version":"7.0.0-alpha1", + "snapshot":false, + "status":"green" }, - "https": { - "total": 0 - } - }, - "event_loop_delay": 46.37134699523449, - "process": { - "mem": { - "heap_max_in_bytes": 171405312, - "heap_used_in_bytes": 143607728, - "resident_set_size_in_bytes": 237985792, - "external_in_bytes": 2075915 + "last_updated":"2018-07-18T00:32:00.948Z", + "collection_interval_ms":5000, + "process":{ + "memory":{ + "heap":{ + "total_bytes":223391744, + "used_bytes":198413592, + "size_limit":1501560832 + }, + "resident_set_size_bytes":347242496 + }, + "event_loop_delay":0.25226891040802, + "pid":46426, + "uptime_ms":1753889 }, - "pid": 18204, - "uptime_ms": 584494 - }, - "os": { - "cpu": { - "load_average": { - "1m": 1.96044921875, - "5m": 2.00732421875, - "15m": 2.07470703125 + "os":{ + "load":{ + "1m":3.50634765625, + "5m":3.76904296875, + "15m":3.54833984375 + }, + "memory":{ + "total_bytes":17179869184, + "free_bytes":31711232, + "used_bytes":17148157952 + }, + "uptime_ms":2187246000 + }, + "response_times":{ + "max_ms":0 + }, + "requests":{ + "total":0, + "disconnects":0, + "status_codes":{ + + } + }, + "concurrent_connections":3, + "usage":{ + "kibana":{ + "index":".kibana", + "dashboard":{ + "total":0 + }, + "visualization":{ + "total":0 + }, + "search":{ + "total":0 + }, + "index_pattern":{ + "total":0 + }, + "graph_workspace":{ + "total":0 + }, + "timelion_sheet":{ + "total":0 + } + }, + "reporting":{ + "available":true, + "enabled":true, + "browser_type":"phantom", + "all":0, + "csv":{ + "available":true, + "total":0 + }, + "printable_pdf":{ + "available":true, + "total":0, + "app":{ + "visualization":0, + "dashboard":0 + }, + "layout":{ + "print":0, + "preserve_layout":0 + } + }, + "status":{ + + }, + "last_day":{ + "all":0, + "csv":{ + "available":true, + "total":0 + }, + "printable_pdf":{ + "available":true, + "total":0, + "app":{ + "visualization":0, + "dashboard":0 + }, + "layout":{ + "print":0, + "preserve_layout":0 + } + }, + "status":{ + + } + }, + "last_7_days":{ + "all":0, + "csv":{ + "available":true, + "total":0 + }, + "printable_pdf":{ + "available":true, + "total":0, + "app":{ + "visualization":0, + "dashboard":0 + }, + "layout":{ + "print":0, + "preserve_layout":0 + } + }, + "status":{ + + } + } } }, - "mem": { - "free_in_bytes": 896122880, - "total_in_bytes": 17179869184 - } + "cluster_uuid":"NkfU5AinRnyFnqBD36zhEw" } -} diff --git a/metricbeat/module/kibana/stats/data.go b/metricbeat/module/kibana/stats/data.go index 126b01c3f2b9..1802cfcb6310 100644 --- a/metricbeat/module/kibana/stats/data.go +++ b/metricbeat/module/kibana/stats/data.go @@ -24,66 +24,59 @@ import ( s "github.com/elastic/beats/libbeat/common/schema" c "github.com/elastic/beats/libbeat/common/schema/mapstriface" "github.com/elastic/beats/metricbeat/mb" + "github.com/elastic/beats/metricbeat/module/kibana" ) var ( schema = s.Schema{ - "cluster_uuid": c.Str("cluster_uuid"), - "name": c.Str("name"), - "uuid": c.Str("uuid"), - "version": c.Dict("version", s.Schema{ - "number": c.Str("number"), - }), - "status": c.Dict("status", s.Schema{ - "overall": c.Dict("overall", s.Schema{ - "state": c.Str("state"), - }), - }), - "response_times": c.Dict("response_times", s.Schema{ - "avg": s.Object{ - "ms": c.Float("avg_in_millis"), - }, - "max": s.Object{ - "ms": c.Int("max_in_millis"), - }, - }), - "requests": c.Dict("requests", s.Schema{ - "total": c.Int("total", s.Optional), - "disconnects": c.Int("disconnects", s.Optional), - }), + "uuid": c.Str("kibana.uuid"), + "name": c.Str("kibana.name"), + "index": c.Str("kibana.name"), + "host": s.Object{ + "name": c.Str("kibana.host"), + }, + "transport_address": c.Str("kibana.transport_address"), + "version": c.Str("kibana.version"), + "snapshot": c.Bool("kibana.snapshot"), + "status": c.Str("kibana.status"), "concurrent_connections": c.Int("concurrent_connections"), - "sockets": c.Dict("sockets", s.Schema{ - "http": c.Dict("http", s.Schema{ - "total": c.Int("total"), - }), - "https": c.Dict("https", s.Schema{ - "total": c.Int("total"), - }), - }), - "event_loop_delay": c.Float("event_loop_delay"), "process": c.Dict("process", s.Schema{ - "memory": c.Dict("mem", s.Schema{ - "heap": s.Object{ - "max": s.Object{ - "bytes": c.Int("heap_max_in_bytes"), + "event_loop_delay": s.Object{ + "ms": c.Float("event_loop_delay"), + }, + "memory": c.Dict("memory", s.Schema{ + "heap": c.Dict("heap", s.Schema{ + "total": s.Object{ + "bytes": c.Int("total_bytes"), }, "used": s.Object{ - "bytes": c.Int("heap_used_in_bytes"), + "bytes": c.Int("used_bytes"), + }, + "size_limit": s.Object{ + "bytes": c.Int("size_limit"), }, - }, - "resident_set_size": s.Object{ - "bytes": c.Int("resident_set_size_in_bytes"), - }, - "external": s.Object{ - "bytes": c.Int("external_in_bytes"), - }, + }), }), - "pid": c.Int("pid"), "uptime": s.Object{ "ms": c.Int("uptime_ms"), }, }), + "request": RequestsDict, + "response_time": c.Dict("response_times", s.Schema{ + "avg": s.Object{ + "ms": c.Int("avg_ms", s.Optional), + }, + "max": s.Object{ + "ms": c.Int("max_ms", s.Optional), + }, + }), } + + // RequestsDict defines how to convert the requests field + RequestsDict = c.Dict("requests", s.Schema{ + "disconnects": c.Int("disconnects", s.Optional), + "total": c.Int("total", s.Optional), + }) ) func eventMapping(r mb.ReporterV2, content []byte) error { @@ -104,10 +97,22 @@ func eventMapping(r mb.ReporterV2, content []byte) error { event.RootFields.Put("service.name", "kibana") // Set elasticsearch cluster id - if clusterID, ok := dataFields["cluster_uuid"]; ok { - delete(dataFields, "cluster_uuid") - event.RootFields.Put("elasticsearch.cluster.id", clusterID) + elasticsearchClusterID, ok := data["cluster_uuid"] + if !ok { + return kibana.ReportErrorForMissingField("cluster_uuid", r) + } + event.RootFields.Put("elasticsearch.cluster.id", elasticsearchClusterID) + + // Set process PID + process, ok := data["process"].(map[string]interface{}) + if !ok { + return kibana.ReportErrorForMissingField("process", r) + } + pid, ok := process["pid"].(float64) + if !ok { + return kibana.ReportErrorForMissingField("process.pid", r) } + event.RootFields.Put("process.pid", int(pid)) event.MetricSetFields = dataFields diff --git a/metricbeat/module/kibana/stats/data_test.go b/metricbeat/module/kibana/stats/data_test.go index ca01331137c3..19daa5562521 100644 --- a/metricbeat/module/kibana/stats/data_test.go +++ b/metricbeat/module/kibana/stats/data_test.go @@ -29,7 +29,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestStats(t *testing.T) { +func TestEventMapping(t *testing.T) { files, err := filepath.Glob("./_meta/test/stats.*.json") assert.NoError(t, err) diff --git a/metricbeat/module/kibana/stats/data_xpack.go b/metricbeat/module/kibana/stats/data_xpack.go new file mode 100644 index 000000000000..d874091dad6c --- /dev/null +++ b/metricbeat/module/kibana/stats/data_xpack.go @@ -0,0 +1,188 @@ +// 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 stats + +import ( + "encoding/json" + "time" + + "github.com/elastic/beats/libbeat/common" + s "github.com/elastic/beats/libbeat/common/schema" + c "github.com/elastic/beats/libbeat/common/schema/mapstriface" + "github.com/elastic/beats/metricbeat/helper/xpack" + "github.com/elastic/beats/metricbeat/mb" + "github.com/elastic/beats/metricbeat/module/kibana" +) + +var ( + schemaXPackMonitoring = s.Schema{ + "concurrent_connections": c.Int("concurrent_connections"), + "os": c.Dict("os", s.Schema{ + "load": c.Dict("load", s.Schema{ + "1m": c.Float("1m"), + "5m": c.Float("5m"), + "15m": c.Float("15m"), + }), + "memory": c.Dict("memory", s.Schema{ + "total_in_bytes": c.Int("total_bytes"), + "free_in_bytes": c.Int("free_bytes"), + "used_in_bytes": c.Int("used_bytes"), + }), + "uptime_in_millis": c.Int("uptime_ms"), + }), + "process": c.Dict("process", s.Schema{ + "event_loop_delay": c.Float("event_loop_delay"), + "memory": c.Dict("memory", s.Schema{ + "heap": c.Dict("heap", s.Schema{ + "total_in_bytes": c.Int("total_bytes"), + "used_in_bytes": c.Int("used_bytes"), + "size_limit": c.Int("size_limit"), + }), + }), + "uptime_in_millis": c.Int("uptime_ms"), + }), + "requests": RequestsDict, + "response_times": c.Dict("response_times", s.Schema{ + "average": c.Int("avg_ms", s.Optional), + "max": c.Int("max_ms", s.Optional), + }, c.DictOptional), + "kibana": c.Dict("kibana", s.Schema{ + "uuid": c.Str("uuid"), + "name": c.Str("name"), + "index": c.Str("index"), + "host": c.Str("host"), + "transport_address": c.Str("transport_address"), + "version": c.Str("version"), + "snapshot": c.Bool("snapshot"), + "status": c.Str("status"), + }), + "usage": c.Dict("usage", s.Schema{ + "index": c.Str("kibana.index"), + "index_pattern": c.Dict("kibana.index_pattern", s.Schema{ + "total": c.Int("total"), + }), + "search": c.Dict("kibana.search", s.Schema{ + "total": c.Int("total"), + }), + "visualization": c.Dict("kibana.visualization", s.Schema{ + "total": c.Int("total"), + }), + "dashboard": c.Dict("kibana.dashboard", s.Schema{ + "total": c.Int("total"), + }), + "timelion_sheet": c.Dict("kibana.timelion_sheet", s.Schema{ + "total": c.Int("total"), + }), + "graph_workspace": c.Dict("kibana.graph_workspace", s.Schema{ + "total": c.Int("total"), + }), + "xpack": s.Object{ + "reporting": c.Dict("reporting", s.Schema{ + "available": c.Bool("available"), + "enabled": c.Bool("enabled"), + "browser_type": c.Str("browser_type"), + "_all": c.Int("all"), + "csv": reportingCsvDict, + "printable_pdf": reportingPrintablePdfDict, + "status": reportingStatusDict, + "lastDay": c.Dict("last_day", reportingPeriodSchema, c.DictOptional), + "last7Days": c.Dict("last_7_days", reportingPeriodSchema, c.DictOptional), + }, c.DictOptional), + }, + }), + } + + reportingCsvDict = c.Dict("csv", s.Schema{ + "available": c.Bool("available"), + "total": c.Int("total"), + }, c.DictOptional) + + reportingPrintablePdfDict = c.Dict("printable_pdf", s.Schema{ + "available": c.Bool("available"), + "total": c.Int("total"), + "app": c.Dict("app", s.Schema{ + "visualization": c.Int("visualization"), + "dashboard": c.Int("dashboard"), + }, c.DictOptional), + "layout": c.Dict("layout", s.Schema{ + "print": c.Int("print"), + "preserve_layout": c.Int("preserve_layout"), + }, c.DictOptional), + }, c.DictOptional) + + reportingStatusDict = c.Dict("status", s.Schema{ + "completed": c.Int("completed", s.Optional), + "failed": c.Int("failed", s.Optional), + "processing": c.Int("processing", s.Optional), + "pending": c.Int("pending", s.Optional), + }, c.DictOptional) + + reportingPeriodSchema = s.Schema{ + "_all": c.Int("all"), + "csv": reportingCsvDict, + "printable_pdf": reportingPrintablePdfDict, + "status": reportingStatusDict, + } +) + +func eventMappingXPack(r mb.ReporterV2, intervalMs int64, content []byte) error { + var data map[string]interface{} + err := json.Unmarshal(content, &data) + if err != nil { + r.Error(err) + return err + } + + kibanaStatsFields, err := schemaXPackMonitoring.Apply(data) + if err != nil { + r.Error(err) + return err + } + + process, ok := data["process"].(map[string]interface{}) + if !ok { + return kibana.ReportErrorForMissingField("process", r) + } + memory, ok := process["memory"].(map[string]interface{}) + if !ok { + return kibana.ReportErrorForMissingField("process.memory", r) + } + + rss, ok := memory["resident_set_size_bytes"].(float64) + if !ok { + return kibana.ReportErrorForMissingField("process.memory.resident_set_size_bytes", r) + } + kibanaStatsFields.Put("process.memory.resident_set_size_in_bytes", int64(rss)) + + timestamp := time.Now() + kibanaStatsFields.Put("timestamp", timestamp) + + var event mb.Event + event.RootFields = common.MapStr{ + "cluster_uuid": data["cluster_uuid"].(string), + "timestamp": timestamp, + "interval_ms": intervalMs, + "type": "kibana_stats", + "kibana_stats": kibanaStatsFields, + } + + event.Index = xpack.MakeMonitoringIndexName(xpack.Kibana) + r.Event(event) + + return nil +} diff --git a/metricbeat/module/kibana/stats/data_xpack_test.go b/metricbeat/module/kibana/stats/data_xpack_test.go new file mode 100644 index 000000000000..d2d2a042b585 --- /dev/null +++ b/metricbeat/module/kibana/stats/data_xpack_test.go @@ -0,0 +1,47 @@ +// 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 !integration + +package stats + +import ( + "io/ioutil" + "path/filepath" + "testing" + + mbtest "github.com/elastic/beats/metricbeat/mb/testing" + + "github.com/stretchr/testify/assert" +) + +func TestEventMappingXPack(t *testing.T) { + + files, err := filepath.Glob("./_meta/test/stats.*.json") + assert.NoError(t, err) + + for _, f := range files { + input, err := ioutil.ReadFile(f) + assert.NoError(t, err) + + reporter := &mbtest.CapturingReporterV2{} + err = eventMappingXPack(reporter, 10000, input) + assert.NoError(t, err, f) + assert.True(t, len(reporter.GetEvents()) >= 1, f) + assert.Equal(t, 0, len(reporter.GetErrors()), f) + } +} diff --git a/metricbeat/module/kibana/stats/stats.go b/metricbeat/module/kibana/stats/stats.go index 67dd0f5b417c..c2dcace05062 100644 --- a/metricbeat/module/kibana/stats/stats.go +++ b/metricbeat/module/kibana/stats/stats.go @@ -22,6 +22,7 @@ import ( "github.com/elastic/beats/metricbeat/helper" "github.com/elastic/beats/metricbeat/mb" "github.com/elastic/beats/metricbeat/mb/parse" + "github.com/elastic/beats/metricbeat/module/kibana" ) // init registers the MetricSet with the central registry. @@ -34,30 +35,42 @@ func init() { var ( hostParser = parse.URLHostParserBuilder{ - DefaultScheme: "http", - PathConfigKey: "path", - DefaultPath: "api/stats", - QueryParams: "extended=true", // make Kibana fetch the cluster_uuid + DefaultScheme: "http", + BasePathConfigKey: "basepath", + DefaultPath: "api/stats", + QueryParams: "extended=true", // make Kibana fetch the cluster_uuid }.Build() ) // MetricSet type defines all fields of the MetricSet type MetricSet struct { mb.BaseMetricSet - http *helper.HTTP + http *helper.HTTP + xPackEnabled bool } // New create a new instance of the MetricSet func New(base mb.BaseMetricSet) (mb.MetricSet, error) { cfgwarn.Experimental("The kibana stats metricset is experimental") + config := kibana.DefaultConfig() + if err := base.Module().UnpackConfig(&config); err != nil { + return nil, err + } + + if config.XPackEnabled { + cfgwarn.Experimental("The experimental xpack.enabled flag in kibana/stats metricset is enabled.") + } + http, err := helper.NewHTTP(base) if err != nil { return nil, err } + return &MetricSet{ base, http, + config.XPackEnabled, }, nil } @@ -71,5 +84,11 @@ func (m *MetricSet) Fetch(r mb.ReporterV2) { return } - eventMapping(r, content) + if m.xPackEnabled { + intervalMs := m.Module().Config().Period.Nanoseconds() / 1000 / 1000 + eventMappingXPack(r, intervalMs, content) + } else { + eventMapping(r, content) + } + } diff --git a/metricbeat/modules.d/kibana.yml.disabled b/metricbeat/modules.d/kibana.yml.disabled index a2476f1b37a5..78f769cd65e1 100644 --- a/metricbeat/modules.d/kibana.yml.disabled +++ b/metricbeat/modules.d/kibana.yml.disabled @@ -6,5 +6,6 @@ # - status period: 10s hosts: ["localhost:5601"] + #basepath: "" #username: "user" #password: "secret"