From 07fa7f699487a2afc13bf0474c83325ee7c77e91 Mon Sep 17 00:00:00 2001 From: Adrian Serrano Date: Mon, 7 Jun 2021 15:39:56 +0200 Subject: [PATCH 01/26] o365: Support non-array Parameters and ExtendedProperties fields (#26164) These fields are documented as being an array of Name-value pairs. However, in some cases they appear as a string field, leading to mapping errors. This patch will perform the expected name-value conversion by creating a new key, "_raw" with the original field value, when the fields are not arrays. --- CHANGELOG.next.asciidoc | 1 + .../module/o365/audit/config/pipeline.js | 6 +- .../module/o365/audit/test/str-params.log | 2 + .../audit/test/str-params.log-expected.json | 131 ++++++++++++++++++ 4 files changed, 139 insertions(+), 1 deletion(-) create mode 100644 x-pack/filebeat/module/o365/audit/test/str-params.log create mode 100644 x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 40506f5bbbf2..8f4be40e0b72 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -382,6 +382,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix `fortinet.firewall.addr` when its a string, not an IP address. {issue}25585[25585] {pull}25608[25608] - Fix incorrect field name appending to `related.hash` in `threatintel.abusechmalware` ingest pipeline. {issue}25151[25151] {pull}25674[25674] - Fix `kibana.log` pipeline when `event.duration` calculation becomes a Long. {issue}24556[24556] {pull}25675[25675] +- o365: Avoid mapping exception for `Parameters` and `ExtendedProperties` fields of string type. {pull}26164[26164] *Heartbeat* diff --git a/x-pack/filebeat/module/o365/audit/config/pipeline.js b/x-pack/filebeat/module/o365/audit/config/pipeline.js index dd1fe588e9e5..9fadd46eb310 100644 --- a/x-pack/filebeat/module/o365/audit/config/pipeline.js +++ b/x-pack/filebeat/module/o365/audit/config/pipeline.js @@ -108,7 +108,11 @@ function makeObjFromNameValuePairArray(options) { return function(evt) { var src = evt.Get(options.from); var dict = {}; - if (src == null || !(src instanceof Array)) return; + if (src == null) return; + if (!(src instanceof Array)) { + evt.Put(options.to, {"_raw": src} ); + return; + } for (var i=0; i < src.length; i++) { var name, value; if (src[i] == null diff --git a/x-pack/filebeat/module/o365/audit/test/str-params.log b/x-pack/filebeat/module/o365/audit/test/str-params.log new file mode 100644 index 000000000000..d5856330b9be --- /dev/null +++ b/x-pack/filebeat/module/o365/audit/test/str-params.log @@ -0,0 +1,2 @@ +{"OriginatingServer": "HE1PR0102MB3228 (15.20.2707.017)", "ClientAppId": "", "OrganizationName": "testsiem.onmicrosoft.com", "ObjectId": "EURPR01A002.prod.outlook.com/Microsoft Exchange Hosted Organizations/testsiem.onmicrosoft.com/DiscoverySearchMailbox{D919BA05-46A6-415f-80AD-7E09334BB852}", "Parameters": "-StartReceivedDate \"4/25/2021 7:00:00 AM\" -EndReceivedDate \"5/27/2021 7:00:00 AM\" -StartExpiresDate \"5/26/2021 7:00:00 AM\" -EndExpiresDate \"6/26/2021 7:00:00 AM\" -PageSize \"100\" -Page \"1\" -MyItems \"True\" -QuarantineTypes (\"Bulk\",\"Spam\",\"Phish\")", "Workload": "Exchange", "OrganizationId": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", "CreationTime": "2020-02-07T20:49:49", "AppId": "", "UserId": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", "UserType": 3, "Version": 1, "ResultStatus": "True", "ExternalAccess": true, "UserKey": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", "Operation": "Set-Mailbox", "Id": "1c7412a6-858d-49ff-3f93-08d7ac0f45bf", "RecordType": 1} +{"CreationTime":"2021-02-05T09:06:07","Id":"550ed0e2-27da-4cbc-9fb8-46add4018800","Operation":"UserLoggedIn","OrganizationId":"48622b8f-44d3-420c-b4a2-510c8165767e","RecordType":15,"ResultStatus":"Success","UserKey":"21119711-1517-43d4-8138-b537dafad016","UserType":0,"Version":1,"Workload":"AzureActiveDirectory","ClientIP":"79.159.11.115","ObjectId":"Unknown","UserId":"root@testsiem4.onmicrosoft.com","AzureActiveDirectoryEventType":1,"ExtendedProperties": "-Name \"foo\" -Description \"\" -HoldNames () -PublicFolderLocation () -ExchangeLocationExclusion () -IncludeUserAppContent \"True\" -SharePointLocationExclusion () -Force \"True\" -Language \"\" -SharePointLocation () -ExchangeLocation (\"All\") -ContentMatchQuery \"(c:c)(senderauthor=abc@foo.com)\"","ModifiedProperties":[],"Actor":[{"ID":"21119711-1517-43d4-8138-b537dafad016","Type":0},{"ID":"root@testsiem4.onmicrosoft.com","Type":5}],"ActorContextId":"48622b8f-44d3-420c-b4a2-510c8165767e","ActorIpAddress":"79.159.11.115","InterSystemsId":"df4c6d6c-4551-4f2d-8766-03700dfccb47","IntraSystemId":"550ed0e2-27da-4cbc-9fb8-46add4018800","SupportTicketId":"","Target":[{"ID":"Unknown","Type":0}],"TargetContextId":"48622b8f-44d3-420c-b4a2-510c8165767e","ApplicationId":"89bee1f7-5e6e-4d8a-9f3d-ecd601259da7","ErrorNumber":"0"} diff --git a/x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json b/x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json new file mode 100644 index 000000000000..764d9283acfd --- /dev/null +++ b/x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json @@ -0,0 +1,131 @@ +[ + { + "@timestamp": "2020-02-07T20:49:49.000Z", + "event.action": "Set-Mailbox", + "event.category": "web", + "event.code": "ExchangeAdmin", + "event.dataset": "o365.audit", + "event.id": "1c7412a6-858d-49ff-3f93-08d7ac0f45bf", + "event.kind": "event", + "event.module": "o365", + "event.outcome": "success", + "event.provider": "Exchange", + "event.type": "info", + "fileset.name": "audit", + "host.id": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", + "host.name": "testsiem.onmicrosoft.com", + "input.type": "log", + "log.offset": 0, + "o365.audit.AppId": "", + "o365.audit.ClientAppId": "", + "o365.audit.CreationTime": "2020-02-07T20:49:49", + "o365.audit.ExternalAccess": true, + "o365.audit.Id": "1c7412a6-858d-49ff-3f93-08d7ac0f45bf", + "o365.audit.ObjectId": "EURPR01A002.prod.outlook.com/Microsoft Exchange Hosted Organizations/testsiem.onmicrosoft.com/DiscoverySearchMailbox{D919BA05-46A6-415f-80AD-7E09334BB852}", + "o365.audit.Operation": "Set-Mailbox", + "o365.audit.OrganizationId": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", + "o365.audit.OrganizationName": "testsiem.onmicrosoft.com", + "o365.audit.OriginatingServer": "HE1PR0102MB3228 (15.20.2707.017)", + "o365.audit.Parameters._raw": "-StartReceivedDate \"4/25/2021 7:00:00 AM\" -EndReceivedDate \"5/27/2021 7:00:00 AM\" -StartExpiresDate \"5/26/2021 7:00:00 AM\" -EndExpiresDate \"6/26/2021 7:00:00 AM\" -PageSize \"100\" -Page \"1\" -MyItems \"True\" -QuarantineTypes (\"Bulk\",\"Spam\",\"Phish\")", + "o365.audit.RecordType": 1, + "o365.audit.ResultStatus": "True", + "o365.audit.UserId": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", + "o365.audit.UserKey": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", + "o365.audit.UserType": 3, + "o365.audit.Version": 1, + "o365.audit.Workload": "Exchange", + "organization.id": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", + "organization.name": "testsiem.onmicrosoft.com", + "server.address": "HE1PR0102MB3228 (15.20.2707.017)", + "service.type": "o365", + "tags": [ + "forwarded" + ], + "user.id": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)" + }, + { + "@timestamp": "2021-02-05T09:06:07.000Z", + "client.address": "79.159.11.115", + "client.ip": "79.159.11.115", + "event.action": "UserLoggedIn", + "event.category": "authentication", + "event.code": "AzureActiveDirectoryStsLogon", + "event.dataset": "o365.audit", + "event.id": "550ed0e2-27da-4cbc-9fb8-46add4018800", + "event.kind": "event", + "event.module": "o365", + "event.outcome": "success", + "event.provider": "AzureActiveDirectory", + "event.type": [ + "authentication_success", + "start" + ], + "fileset.name": "audit", + "host.id": "48622b8f-44d3-420c-b4a2-510c8165767e", + "host.name": "testsiem4.onmicrosoft.com", + "input.type": "log", + "log.offset": 1014, + "network.type": "ipv4", + "o365.audit.Actor": [ + { + "ID": "21119711-1517-43d4-8138-b537dafad016", + "Type": 0 + }, + { + "ID": "root@testsiem4.onmicrosoft.com", + "Type": 5 + } + ], + "o365.audit.ActorContextId": "48622b8f-44d3-420c-b4a2-510c8165767e", + "o365.audit.ActorIpAddress": "79.159.11.115", + "o365.audit.ApplicationId": "89bee1f7-5e6e-4d8a-9f3d-ecd601259da7", + "o365.audit.AzureActiveDirectoryEventType": 1, + "o365.audit.ClientIP": "79.159.11.115", + "o365.audit.CreationTime": "2021-02-05T09:06:07", + "o365.audit.ErrorNumber": "0", + "o365.audit.ExtendedProperties._raw": "-Name \"foo\" -Description \"\" -HoldNames () -PublicFolderLocation () -ExchangeLocationExclusion () -IncludeUserAppContent \"True\" -SharePointLocationExclusion () -Force \"True\" -Language \"\" -SharePointLocation () -ExchangeLocation (\"All\") -ContentMatchQuery \"(c:c)(senderauthor=abc@foo.com)\"", + "o365.audit.Id": "550ed0e2-27da-4cbc-9fb8-46add4018800", + "o365.audit.InterSystemsId": "df4c6d6c-4551-4f2d-8766-03700dfccb47", + "o365.audit.IntraSystemId": "550ed0e2-27da-4cbc-9fb8-46add4018800", + "o365.audit.ObjectId": "Unknown", + "o365.audit.Operation": "UserLoggedIn", + "o365.audit.OrganizationId": "48622b8f-44d3-420c-b4a2-510c8165767e", + "o365.audit.RecordType": 15, + "o365.audit.ResultStatus": "Success", + "o365.audit.SupportTicketId": "", + "o365.audit.Target": [ + { + "ID": "Unknown", + "Type": 0 + } + ], + "o365.audit.TargetContextId": "48622b8f-44d3-420c-b4a2-510c8165767e", + "o365.audit.UserId": "root@testsiem4.onmicrosoft.com", + "o365.audit.UserKey": "21119711-1517-43d4-8138-b537dafad016", + "o365.audit.UserType": 0, + "o365.audit.Version": 1, + "o365.audit.Workload": "AzureActiveDirectory", + "organization.id": "48622b8f-44d3-420c-b4a2-510c8165767e", + "related.ip": "79.159.11.115", + "related.user": "root", + "service.type": "o365", + "source.as.number": 3352, + "source.as.organization.name": "Telefonica De Espana", + "source.geo.city_name": "Barcelona", + "source.geo.continent_name": "Europe", + "source.geo.country_iso_code": "ES", + "source.geo.country_name": "Spain", + "source.geo.location.lat": 41.3891, + "source.geo.location.lon": 2.1611, + "source.geo.region_iso_code": "ES-B", + "source.geo.region_name": "Barcelona", + "source.ip": "79.159.11.115", + "tags": [ + "forwarded" + ], + "user.domain": "testsiem4.onmicrosoft.com", + "user.email": "root@testsiem4.onmicrosoft.com", + "user.id": "root@testsiem4.onmicrosoft.com", + "user.name": "root" + } +] \ No newline at end of file From 3b50a28dff85caf6b5e0ecc77a6b24f7e681628a Mon Sep 17 00:00:00 2001 From: Adrian Serrano Date: Mon, 7 Jun 2021 15:41:31 +0200 Subject: [PATCH 02/26] auditd: Fix kernel deadlock after ENOBUFS (#26032) This fixes a deadlock when the netlink channel is congested (initialization fails with "no buffer space available" / errno=ENOBUFS). Closes #26031 --- CHANGELOG.next.asciidoc | 1 + auditbeat/module/auditd/audit_linux.go | 50 +++++++++++++++++++++++--- 2 files changed, 46 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 8f4be40e0b72..de570f85c4e9 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -259,6 +259,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - system/socket: Fixed start failure when run under config reloader. {issue}20851[20851] {pull}21693[21693] - system/socket: Having some CPUs unavailable to Auditbeat could cause startup errors or event loss. {pull}22827[22827] - Note incompatibility of system/socket on ARM. {pull}23381[23381] +- auditd: Fix kernel deadlock when netlink congestion causes "no buffer space available" errors. {issue}26031[26031] {pull}26032[26032] *Filebeat* diff --git a/auditbeat/module/auditd/audit_linux.go b/auditbeat/module/auditd/audit_linux.go index 1cd9133a9179..7324e423986d 100644 --- a/auditbeat/module/auditd/audit_linux.go +++ b/auditbeat/module/auditd/audit_linux.go @@ -51,6 +51,8 @@ const ( lostEventsUpdateInterval = time.Second * 15 maxDefaultStreamBufferConsumers = 4 + + setPIDMaxRetries = 5 ) type backpressureStrategy uint8 @@ -137,10 +139,32 @@ func newAuditClient(c *Config, log *logp.Logger) (*libaudit.AuditClient, error) return libaudit.NewAuditClient(nil) } +func closeAuditClient(client *libaudit.AuditClient) error { + discard := func(bytes []byte) ([]syscall.NetlinkMessage, error) { + return nil, nil + } + // Drain the netlink channel in parallel to Close() to prevent a deadlock. + // This goroutine will terminate once receive from netlink errors (EBADF, + // EBADFD, or any other error). This happens because the fd is closed. + go func() { + for { + _, err := client.Netlink.Receive(true, discard) + switch err { + case nil, syscall.EINTR: + case syscall.EAGAIN: + time.Sleep(50 * time.Millisecond) + default: + return + } + } + }() + return client.Close() +} + // Run initializes the audit client and receives audit messages from the // kernel until the reporter's done channel is closed. func (ms *MetricSet) Run(reporter mb.PushReporterV2) { - defer ms.client.Close() + defer closeAuditClient(ms.client) if err := ms.addRules(reporter); err != nil { reporter.Error(err) @@ -164,7 +188,7 @@ func (ms *MetricSet) Run(reporter mb.PushReporterV2) { go func() { defer func() { // Close the most recently allocated "client" instance. if client != nil { - client.Close() + closeAuditClient(client) } }() timer := time.NewTicker(lostEventsUpdateInterval) @@ -178,7 +202,7 @@ func (ms *MetricSet) Run(reporter mb.PushReporterV2) { ms.updateKernelLostMetric(status.Lost) } else { ms.log.Error("get status request failed:", err) - if err = client.Close(); err != nil { + if err = closeAuditClient(client); err != nil { ms.log.Errorw("Error closing audit monitoring client", "error", err) } client, err = libaudit.NewAuditClient(nil) @@ -233,7 +257,7 @@ func (ms *MetricSet) addRules(reporter mb.PushReporterV2) error { if err != nil { return errors.Wrap(err, "failed to create audit client for adding rules") } - defer client.Close() + defer closeAuditClient(client) // Don't attempt to change configuration if audit rules are locked (enabled == 2). // Will result in EPERM. @@ -350,10 +374,12 @@ func (ms *MetricSet) initClient() error { return errors.Wrap(err, "failed to enable auditing in the kernel") } } + if err := ms.client.WaitForPendingACKs(); err != nil { return errors.Wrap(err, "failed to wait for ACKs") } - if err := ms.client.SetPID(libaudit.WaitForReply); err != nil { + + if err := ms.setPID(setPIDMaxRetries); err != nil { if errno, ok := err.(syscall.Errno); ok && errno == syscall.EEXIST && status.PID != 0 { return fmt.Errorf("failed to set audit PID. An audit process is already running (PID %d)", status.PID) } @@ -362,6 +388,20 @@ func (ms *MetricSet) initClient() error { return nil } +func (ms *MetricSet) setPID(retries int) (err error) { + if err = ms.client.SetPID(libaudit.WaitForReply); err == nil || errors.Cause(err) != syscall.ENOBUFS || retries == 0 { + return err + } + // At this point the netlink channel is congested (ENOBUFS). + // Drain and close the client, then retry with a new client. + closeAuditClient(ms.client) + if ms.client, err = newAuditClient(&ms.config, ms.log); err != nil { + return errors.Wrapf(err, "failed to recover from ENOBUFS") + } + ms.log.Info("Recovering from ENOBUFS ...") + return ms.setPID(retries - 1) +} + func (ms *MetricSet) updateKernelLostMetric(lost uint32) { if !ms.kernelLost.enabled { return From 8bbb26f437df9fdac6f8504fa03268137e04ba6d Mon Sep 17 00:00:00 2001 From: Adrian Serrano Date: Mon, 7 Jun 2021 16:10:04 +0200 Subject: [PATCH 03/26] http_endpoint: Allow receiving multiple documents on a single request (#25764) Updates Filebeat's http_endpoint to produce multiple documents from a single POST request. This extends the application/json format handling to accept arrays of objects, and adds support for the NDJSON format (application/x-ndjson). --- CHANGELOG.next.asciidoc | 1 + .../filebeat/input/http_endpoint/handler.go | 62 +++++++------ .../input/http_endpoint/handler_test.go | 93 +++++++++++++++++++ .../tests/system/test_http_endpoint.py | 62 ++++++++++++- 4 files changed, 187 insertions(+), 31 deletions(-) create mode 100644 x-pack/filebeat/input/http_endpoint/handler_test.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index de570f85c4e9..a636265ece85 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -810,6 +810,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add fingerprint processor to generate fixed ids for `google_workspace` events. {pull}25841[25841] - Update PanOS module to parse HIP Match logs. {issue}24350[24350] {pull}25686[25686] - Enhance GCP module to populate orchestrator.* fields for GKE / K8S logs {pull}25368[25368] +- http_endpoint: Support multiple documents in a single request by POSTing an array or NDJSON format. {pull}25764[25764] *Heartbeat* diff --git a/x-pack/filebeat/input/http_endpoint/handler.go b/x-pack/filebeat/input/http_endpoint/handler.go index f821301fe798..6d1c0374dc39 100644 --- a/x-pack/filebeat/input/http_endpoint/handler.go +++ b/x-pack/filebeat/input/http_endpoint/handler.go @@ -5,15 +5,14 @@ package http_endpoint import ( - "bytes" "encoding/json" - "errors" "fmt" "io" - "io/ioutil" "net/http" "time" + "github.com/pkg/errors" + stateless "github.com/elastic/beats/v7/filebeat/input/v2/input-stateless" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common" @@ -36,19 +35,20 @@ var ( // Triggers if middleware validation returns successful func (h *httpHandler) apiResponse(w http.ResponseWriter, r *http.Request) { - obj, status, err := httpReadJsonObject(r.Body) + objs, status, err := httpReadJSON(r.Body) if err != nil { - w.Header().Add("Content-Type", "application/json") sendErrorResponse(w, status, err) return } - h.publishEvent(obj) - w.Header().Add("Content-Type", "application/json") + for _, obj := range objs { + h.publishEvent(obj) + } h.sendResponse(w, h.responseCode, h.responseBody) } func (h *httpHandler) sendResponse(w http.ResponseWriter, status int, message string) { + w.Header().Add("Content-Type", "application/json") w.WriteHeader(status) io.WriteString(w, message) } @@ -82,32 +82,34 @@ func sendErrorResponse(w http.ResponseWriter, status int, err error) { e.Encode(common.MapStr{"message": err.Error()}) } -func httpReadJsonObject(body io.Reader) (obj common.MapStr, status int, err error) { +func httpReadJSON(body io.Reader) (objs []common.MapStr, status int, err error) { if body == http.NoBody { return nil, http.StatusNotAcceptable, errBodyEmpty } - contents, err := ioutil.ReadAll(body) - if err != nil { - return nil, http.StatusInternalServerError, fmt.Errorf("failed reading body: %w", err) - } - - if !isObject(contents) { - return nil, http.StatusBadRequest, errUnsupportedType - } - - obj = common.MapStr{} - if err := json.Unmarshal(contents, &obj); err != nil { - return nil, http.StatusBadRequest, fmt.Errorf("malformed JSON body: %w", err) - } - - return obj, 0, nil -} - -func isObject(b []byte) bool { - obj := bytes.TrimLeft(b, " \t\r\n") - if len(obj) > 0 && obj[0] == '{' { - return true + decoder := json.NewDecoder(body) + for idx := 0; ; idx++ { + var obj interface{} + if err := decoder.Decode(&obj); err != nil { + if err == io.EOF { + break + } + return nil, http.StatusBadRequest, errors.Wrapf(err, "malformed JSON object at stream position %d", idx) + } + switch v := obj.(type) { + case map[string]interface{}: + objs = append(objs, v) + case []interface{}: + for listIdx, listObj := range v { + asMap, ok := listObj.(map[string]interface{}) + if !ok { + return nil, http.StatusBadRequest, fmt.Errorf("%v at stream %d index %d", errUnsupportedType, idx, listIdx) + } + objs = append(objs, asMap) + } + default: + return nil, http.StatusBadRequest, errUnsupportedType + } } - return false + return objs, 0, nil } diff --git a/x-pack/filebeat/input/http_endpoint/handler_test.go b/x-pack/filebeat/input/http_endpoint/handler_test.go new file mode 100644 index 000000000000..ef1b36d2e733 --- /dev/null +++ b/x-pack/filebeat/input/http_endpoint/handler_test.go @@ -0,0 +1,93 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package http_endpoint + +import ( + "net/http" + "reflect" + "strings" + "testing" + + "github.com/elastic/beats/v7/libbeat/common" +) + +func Test_httpReadJSON(t *testing.T) { + tests := []struct { + name string + body string + wantObjs []common.MapStr + wantStatus int + wantErr bool + }{ + { + name: "single object", + body: `{"a": 42, "b": "c"}`, + wantObjs: []common.MapStr{{"a": float64(42), "b": "c"}}, + }, + { + name: "array accepted", + body: `[{"a":"b"},{"c":"d"}]`, + wantObjs: []common.MapStr{{"a": "b"}, {"c": "d"}}, + }, + { + name: "not an object not accepted", + body: `42`, + wantStatus: http.StatusBadRequest, + wantErr: true, + }, + { + name: "not an object mixed", + body: "[{\"a\":1},\n42,\n{\"a\":2}]", + wantStatus: http.StatusBadRequest, + wantErr: true, + }, + { + name: "sequence of objects accepted (CRLF)", + body: "{\"a\":1}\r\n{\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "sequence of objects accepted (LF)", + body: "{\"a\":1}\n{\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "sequence of objects accepted (SP)", + body: "{\"a\":1} {\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "sequence of objects accepted (no separator)", + body: "{\"a\":1}{\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "not an object in sequence", + body: "{\"a\":1}\n42\n{\"a\":2}", + wantStatus: http.StatusBadRequest, + wantErr: true, + }, + { + name: "array of objects in stream", + body: `{"a":1} [{"a":2},{"a":3}] {"a":4}`, + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}, {"a": float64(3)}, {"a": float64(4)}}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotObjs, gotStatus, err := httpReadJSON(strings.NewReader(tt.body)) + if (err != nil) != tt.wantErr { + t.Errorf("httpReadJSON() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(gotObjs, tt.wantObjs) { + t.Errorf("httpReadJSON() gotObjs = %v, want %v", gotObjs, tt.wantObjs) + } + if gotStatus != tt.wantStatus { + t.Errorf("httpReadJSON() gotStatus = %v, want %v", gotStatus, tt.wantStatus) + } + }) + } +} diff --git a/x-pack/filebeat/tests/system/test_http_endpoint.py b/x-pack/filebeat/tests/system/test_http_endpoint.py index 7be145945e64..688b46852e2d 100644 --- a/x-pack/filebeat/tests/system/test_http_endpoint.py +++ b/x-pack/filebeat/tests/system/test_http_endpoint.py @@ -84,6 +84,66 @@ def test_http_endpoint_request(self): assert output[0]["input.type"] == "http_endpoint" assert output[0]["json.{}".format(self.prefix)] == message + def test_http_endpoint_request_multiple_documents(self): + """ + Test http_endpoint input with multiple documents on a single HTTP request. + """ + self.get_config() + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + + N = 10 + message = "somerandommessage_{}" + payload = [{self.prefix: message.format(i)} for i in range(N)] + headers = {"Content-Type": "application/json", "Accept": "application/json"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + self.wait_until(lambda: self.output_count(lambda x: x == N)) + filebeat.check_kill_and_wait() + + output = self.read_output() + + print("response:", r.status_code, r.text) + + assert r.text == '{"message": "success"}' + + assert len(output) == N + for i in range(N): + assert output[i]["input.type"] == "http_endpoint" + assert output[i]["json.{}".format(self.prefix)] == message.format(i) + + def test_http_endpoint_request_ndjson(self): + """ + Test http_endpoint input with multiple documents on a single HTTP request (NDJSON). + """ + + options = """ + content_type: application/x-ndjson +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + + N = 10 + message = "somerandommessage_{}" + payload = "\n".join([json.dumps({self.prefix: message.format(i)}) for i in range(N)]) + headers = {"Content-Type": "application/x-ndjson", "Accept": "application/json"} + r = requests.post(self.url, headers=headers, data=payload) + + self.wait_until(lambda: self.output_count(lambda x: x == N)) + filebeat.check_kill_and_wait() + + output = self.read_output() + + print("response:", r.status_code, r.text) + + assert r.text == '{"message": "success"}' + + assert len(output) == N + for i in range(N): + assert output[i]["input.type"] == "http_endpoint" + assert output[i]["json.{}".format(self.prefix)] == message.format(i) + def test_http_endpoint_wrong_content_header(self): """ Test http_endpoint input with wrong content header. @@ -283,7 +343,7 @@ def test_http_endpoint_malformed_json(self): print("response:", r.status_code, r.text) assert r.status_code == 400 - self.assertRegex(r.json()['message'], 'malformed JSON body') + self.assertRegex(r.json()['message'], 'malformed JSON') def test_http_endpoint_get_request(self): """ From 447bac937949bce27cee3a5c9ff10669de16555f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?No=C3=A9mi=20V=C3=A1nyi?= Date: Mon, 7 Jun 2021 18:00:26 +0200 Subject: [PATCH 04/26] Include date separator in the filename prefix of `dateRotator` to make sure nothing gets purged accidentally (#26176) ## What does this PR do? This PR changes the log file prefix when using date rotation in Beats. Previously the `-` was not included, so in the list of rotated files every file that started with the configured file prefix were included. ## Why is it important? If the binary is under the same path as the value configured in `logging.files.path` and `logging.files.name`, when the number of rotated log files gets bigger than the one configured in `loggin.files.keepfiles`, the binary is purged on rotation. The workaround is to put the log files in a separate folder. --- CHANGELOG.next.asciidoc | 1 + libbeat/common/file/rotator.go | 8 ++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index a636265ece85..b516e7b87927 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -238,6 +238,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix 'make setup' instructions for a new beat {pull}24944[24944] - Fix out of date FreeBSD vagrantbox. {pull}25652[25652] - Fix handling of `file_selectors` in aws-s3 input. {pull}25792[25792] +- Include date separator in the filename prefix of `dateRotator` to make sure nothing gets purged accidentally {pull}26176[26176] *Auditbeat* diff --git a/libbeat/common/file/rotator.go b/libbeat/common/file/rotator.go index d6c35d6e1023..633f94232ef5 100644 --- a/libbeat/common/file/rotator.go +++ b/libbeat/common/file/rotator.go @@ -435,11 +435,11 @@ func newRotater(log Logger, s SuffixType, filename string, maxBackups uint, inte func newDateRotater(log Logger, filename string) rotater { d := &dateRotator{ log: log, - filenamePrefix: filename, + filenamePrefix: filename + "-", format: "20060102150405", } - d.currentFilename = d.filenamePrefix + "-" + time.Now().Format(d.format) + d.currentFilename = d.filenamePrefix + time.Now().Format(d.format) files, err := filepath.Glob(d.filenamePrefix + "*") if err != nil { return d @@ -467,7 +467,7 @@ func (d *dateRotator) Rotate(reason rotateReason, rotateTime time.Time) error { d.log.Debugw("Rotating file", "filename", d.currentFilename, "reason", reason) } - d.currentFilename = d.filenamePrefix + "-" + rotateTime.Format(d.format) + d.currentFilename = d.filenamePrefix + rotateTime.Format(d.format) return nil } @@ -493,7 +493,7 @@ func (d *dateRotator) SortModTimeLogs(strings []string) { } func (d *dateRotator) OrderLog(filename string) time.Time { - ts, err := time.Parse(d.format, filepath.Base(filename)) + ts, err := time.Parse(d.filenamePrefix+d.format, filepath.Base(filename)) if err != nil { return time.Time{} } From cb085d0f974d0b8e39cf8e35508be6d83354211b Mon Sep 17 00:00:00 2001 From: Vignesh Shanmugam Date: Mon, 7 Jun 2021 13:10:08 -0700 Subject: [PATCH 05/26] [Heartbeat]: add mappings for performance metrics (#26140) * [Heartbeat]: add mappings for performance metrics * build new mappings * address review comments * update fields Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> --- heartbeat/_meta/fields.common.yml | 58 +++++++++++++++++-- heartbeat/docs/fields.asciidoc | 92 ++++++++++++++++++++++++++++++ heartbeat/include/fields.go | 2 +- x-pack/heartbeat/include/fields.go | 2 +- 4 files changed, 146 insertions(+), 8 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index ef6caae60bd6..ec4c779e0203 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -174,6 +174,52 @@ type: text - name: stack type: text + - name: browser + type: group + fields: + - name: experience + type: group + fields: + - name: name + type: keyword + - name: type + type: text + description: > + denotes the 'mark' event + - name: start + type: long + description: > + offset of time relative to journey start in milliseconds + - name: user_timing + type: group + fields: + - name: name + type: keyword + - name: type + type: text + description: > + could be one of mark or measure event types. + - name: start + type: long + description: > + offset of time relative to journey start in milliseconds + - name: end + type: long + description: > + offset of time relative to journey start in milliseconds + - name: layout_shift + type: group + fields: + - name: name + type: keyword + - name: score + type: integer + - name: exists + type: boolean + description: > + flag that indicates if there was any layout shift events + present on the page. + - key: http title: "HTTP monitor" description: @@ -379,12 +425,12 @@ type: group description: Detailed x509 certificate metadata fields: - - name: version_number - type: keyword - ignore_above: 1024 - description: Version of x509 format. - example: 3 - default_field: false + - name: version_number + type: keyword + ignore_above: 1024 + description: Version of x509 format. + example: 3 + default_field: false - key: icmp title: "ICMP" diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index 64910449412f..0f88582dd427 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -10499,6 +10499,98 @@ type: text -- + + +*`synthetics.browser.experience.name`*:: ++ +-- +type: keyword + +-- + +*`synthetics.browser.experience.type`*:: ++ +-- +denotes the 'mark' event + + +type: text + +-- + +*`synthetics.browser.experience.start`*:: ++ +-- +offset of time relative to journey start in milliseconds + + +type: long + +-- + + +*`synthetics.browser.user_timing.name`*:: ++ +-- +type: keyword + +-- + +*`synthetics.browser.user_timing.type`*:: ++ +-- +could be one of mark or measure event types. + + +type: text + +-- + +*`synthetics.browser.user_timing.start`*:: ++ +-- +offset of time relative to journey start in milliseconds + + +type: long + +-- + +*`synthetics.browser.user_timing.end`*:: ++ +-- +offset of time relative to journey start in milliseconds + + +type: long + +-- + + +*`synthetics.browser.layout_shift.name`*:: ++ +-- +type: keyword + +-- + +*`synthetics.browser.layout_shift.score`*:: ++ +-- +type: integer + +-- + +*`synthetics.browser.layout_shift.exists`*:: ++ +-- +flag that indicates if there was any layout shift events present on the page. + + +type: boolean + +-- + [[exported-fields-tcp]] == TCP layer fields diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 2ad529259c33..d7d45a800a7a 100644 --- a/heartbeat/include/fields.go +++ b/heartbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/x-pack/heartbeat/include/fields.go b/x-pack/heartbeat/include/fields.go index a7f85b08864e..6ed4d0ea2aa4 100644 --- a/x-pack/heartbeat/include/fields.go +++ b/x-pack/heartbeat/include/fields.go @@ -19,5 +19,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } From db6738eac1881cd52af7dea8cdcb37f8f67ef0e3 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 7 Jun 2021 22:49:19 -0500 Subject: [PATCH 06/26] [Heartbeat] Dedupe screenshots / Extra Args (#25808) --- CHANGELOG.next.asciidoc | 1 + heartbeat/_meta/fields.common.yml | 17 +++ heartbeat/docs/fields.asciidoc | 34 ++++++ .../docs/monitors/monitor-browser.asciidoc | 12 ++ heartbeat/include/fields.go | 2 +- x-pack/heartbeat/include/fields.go | 2 +- x-pack/heartbeat/monitors/browser/browser.go | 38 +----- x-pack/heartbeat/monitors/browser/config.go | 5 +- x-pack/heartbeat/monitors/browser/suite.go | 108 ++++++++++++++++++ .../monitors/browser/suite_runner.go | 69 ----------- .../{suite_runner_test.go => suite_test.go} | 40 +++++++ .../monitors/browser/synthexec/enrich.go | 11 ++ .../monitors/browser/synthexec/enrich_test.go | 86 +++++++++++++- .../monitors/browser/synthexec/synthexec.go | 26 ++--- .../monitors/browser/synthexec/synthtypes.go | 1 + 15 files changed, 329 insertions(+), 123 deletions(-) create mode 100644 x-pack/heartbeat/monitors/browser/suite.go delete mode 100644 x-pack/heartbeat/monitors/browser/suite_runner.go rename x-pack/heartbeat/monitors/browser/{suite_runner_test.go => suite_test.go} (76%) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index b516e7b87927..365f7f96ef58 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -106,6 +106,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Change logging in logs input to structure logging. Some log message formats have changed. {pull}25299[25299] *Heartbeat* +- Add support for screenshot blocks and use newer synthetics flags that only works in newer synthetics betas. {pull}25808[25808] *Journalbeat* diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index ec4c779e0203..ae49446e6ab4 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -174,6 +174,23 @@ type: text - name: stack type: text + - name: screenshot_ref + type: group + dynamic: false + fields: + - name: width + type: integer + description: Width of the full screenshot in pixels. + - name: height + type: integer + description: Height of the full screenshot in pixels + - name: blocks + type: group + description: Attributes representing individual screenshot blocks. Only hash is indexed since it's the only one we'd query on. + fields: + - name: hash + type: keyword + description: Hash that uniquely identifies this image by content. Corresponds to block document id. - name: browser type: group fields: diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index 0f88582dd427..a9dfe8a1d2e7 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -10500,6 +10500,40 @@ type: text -- +*`synthetics.screenshot_ref.width`*:: ++ +-- +Width of the full screenshot in pixels. + +type: integer + +-- + +*`synthetics.screenshot_ref.height`*:: ++ +-- +Height of the full screenshot in pixels + +type: integer + +-- + +[float] +=== blocks + +Attributes representing individual screenshot blocks. Only hash is indexed since it's the only one we'd query on. + + +*`synthetics.screenshot_ref.blocks.hash`*:: ++ +-- +Hash that uniquely identifies this image by content. Corresponds to block document id. + +type: keyword + +-- + + *`synthetics.browser.experience.name`*:: + diff --git a/heartbeat/docs/monitors/monitor-browser.asciidoc b/heartbeat/docs/monitors/monitor-browser.asciidoc index d2e504809242..69ce06f88ca4 100644 --- a/heartbeat/docs/monitors/monitor-browser.asciidoc +++ b/heartbeat/docs/monitors/monitor-browser.asciidoc @@ -104,3 +104,15 @@ Example configuration: local: path: "/path/to/synthetics/journeys" ------------------------------------------------------------------------------- + +[float] +[[monitor-browser-sandbox]] +==== `sandbox` + +Set this option to `true` to enable the normally disabled chromium sandbox. Defaults to false. + +[float] +[[monitor-browser-synthetics-args]] +==== `synthetics_args` + +Extra arguments to pass to the synthetics agent package. Takes a list of strings. \ No newline at end of file diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index d7d45a800a7a..a1253b4645bf 100644 --- a/heartbeat/include/fields.go +++ b/heartbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/x-pack/heartbeat/include/fields.go b/x-pack/heartbeat/include/fields.go index 6ed4d0ea2aa4..db01484fffad 100644 --- a/x-pack/heartbeat/include/fields.go +++ b/x-pack/heartbeat/include/fields.go @@ -19,5 +19,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/x-pack/heartbeat/monitors/browser/browser.go b/x-pack/heartbeat/monitors/browser/browser.go index 4e8bc4ef8908..1e37961a4e85 100644 --- a/x-pack/heartbeat/monitors/browser/browser.go +++ b/x-pack/heartbeat/monitors/browser/browser.go @@ -5,18 +5,14 @@ package browser import ( - "context" "fmt" "os" "os/user" "sync" - "github.com/elastic/beats/v7/heartbeat/monitors/jobs" "github.com/elastic/beats/v7/heartbeat/monitors/plugin" - "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common" "github.com/elastic/beats/v7/libbeat/logp" - "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser/synthexec" ) func init() { @@ -25,14 +21,14 @@ func init() { var showExperimentalOnce = sync.Once{} -var NotSyntheticsCapableError = fmt.Errorf("synthetic monitors cannot be created outside the official elastic docker image") +var ErrNotSyntheticsCapableError = fmt.Errorf("synthetic monitors cannot be created outside the official elastic docker image") func create(name string, cfg *common.Config) (p plugin.Plugin, err error) { // We don't want users running synthetics in environments that don't have the required GUI libraries etc, so we check // this flag. When we're ready to support the many possible configurations of systems outside the docker environment // we can remove this check. if os.Getenv("ELASTIC_SYNTHETICS_CAPABLE") != "true" { - return plugin.Plugin{}, NotSyntheticsCapableError + return plugin.Plugin{}, ErrNotSyntheticsCapableError } showExperimentalOnce.Do(func() { @@ -47,36 +43,10 @@ func create(name string, cfg *common.Config) (p plugin.Plugin, err error) { return plugin.Plugin{}, fmt.Errorf("script monitors cannot be run as root! Current UID is %s", curUser.Uid) } - ss, err := NewSuite(cfg) + s, err := NewSuite(cfg) if err != nil { return plugin.Plugin{}, err } - extraArgs := []string{} - if ss.suiteCfg.Sandbox { - extraArgs = append(extraArgs, "--sandbox") - } - - var j jobs.Job - if src, ok := ss.InlineSource(); ok { - j = synthexec.InlineJourneyJob(context.TODO(), src, ss.Params(), extraArgs...) - } else { - j = func(event *beat.Event) ([]jobs.Job, error) { - err := ss.Fetch() - if err != nil { - return nil, fmt.Errorf("could not fetch for suite job: %w", err) - } - sj, err := synthexec.SuiteJob(context.TODO(), ss.Workdir(), ss.Params(), extraArgs...) - if err != nil { - return nil, err - } - return sj(event) - } - } - - return plugin.Plugin{ - Jobs: []jobs.Job{j}, - Close: ss.Close, - Endpoints: 1, - }, nil + return s.plugin(), nil } diff --git a/x-pack/heartbeat/monitors/browser/config.go b/x-pack/heartbeat/monitors/browser/config.go index de226f8ca796..0da4eb0a8603 100644 --- a/x-pack/heartbeat/monitors/browser/config.go +++ b/x-pack/heartbeat/monitors/browser/config.go @@ -25,8 +25,9 @@ type Config struct { // Name is optional for lightweight checks but required for browsers Name string `config:"name"` // Id is optional for lightweight checks but required for browsers - Id string `config:"id"` - Sandbox bool `config:"sandbox"` + Id string `config:"id"` + Sandbox bool `config:"sandbox"` + SyntheticsArgs []string `config:"synthetics_args"` } var ErrNameRequired = fmt.Errorf("config 'name' must be specified for this monitor") diff --git a/x-pack/heartbeat/monitors/browser/suite.go b/x-pack/heartbeat/monitors/browser/suite.go new file mode 100644 index 000000000000..d265c0a4b3f2 --- /dev/null +++ b/x-pack/heartbeat/monitors/browser/suite.go @@ -0,0 +1,108 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package browser + +import ( + "context" + "fmt" + + "github.com/elastic/beats/v7/heartbeat/monitors/jobs" + "github.com/elastic/beats/v7/heartbeat/monitors/plugin" + "github.com/elastic/beats/v7/libbeat/beat" + "github.com/elastic/beats/v7/libbeat/common" + "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser/synthexec" +) + +type JourneyLister func(ctx context.Context, suitePath string, params common.MapStr) (journeyNames []string, err error) + +type Suite struct { + rawCfg *common.Config + suiteCfg *Config +} + +func NewSuite(rawCfg *common.Config) (*Suite, error) { + s := &Suite{ + rawCfg: rawCfg, + suiteCfg: DefaultConfig(), + } + err := rawCfg.Unpack(s.suiteCfg) + if err != nil { + return nil, ErrBadConfig(err) + } + + return s, nil +} + +func ErrBadConfig(err error) error { + return fmt.Errorf("could not parse suite config: %w", err) +} + +func (s *Suite) String() string { + panic("implement me") +} + +func (s *Suite) Fetch() error { + return s.suiteCfg.Source.Active().Fetch() +} + +func (s *Suite) Workdir() string { + return s.suiteCfg.Source.Active().Workdir() +} + +func (s *Suite) InlineSource() (string, bool) { + if s.suiteCfg.Source.Inline != nil { + return s.suiteCfg.Source.Inline.Script, true + } + return "", false +} + +func (s *Suite) Params() map[string]interface{} { + return s.suiteCfg.Params +} + +func (s *Suite) Close() error { + if s.suiteCfg.Source.ActiveMemo != nil { + s.suiteCfg.Source.ActiveMemo.Close() + } + + return nil +} + +func (s *Suite) extraArgs() []string { + extraArgs := s.suiteCfg.SyntheticsArgs + if s.suiteCfg.Sandbox { + extraArgs = append(extraArgs, "--sandbox") + } + + return extraArgs +} + +func (s *Suite) jobs() []jobs.Job { + var j jobs.Job + if src, ok := s.InlineSource(); ok { + j = synthexec.InlineJourneyJob(context.TODO(), src, s.Params(), s.extraArgs()...) + } else { + j = func(event *beat.Event) ([]jobs.Job, error) { + err := s.Fetch() + if err != nil { + return nil, fmt.Errorf("could not fetch for suite job: %w", err) + } + sj, err := synthexec.SuiteJob(context.TODO(), s.Workdir(), s.Params(), s.extraArgs()...) + if err != nil { + return nil, err + } + return sj(event) + } + } + return []jobs.Job{j} +} + +func (s *Suite) plugin() plugin.Plugin { + return plugin.Plugin{ + Jobs: s.jobs(), + Close: s.Close, + Endpoints: 1, + } +} diff --git a/x-pack/heartbeat/monitors/browser/suite_runner.go b/x-pack/heartbeat/monitors/browser/suite_runner.go deleted file mode 100644 index 6e58ae932f10..000000000000 --- a/x-pack/heartbeat/monitors/browser/suite_runner.go +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one -// or more contributor license agreements. Licensed under the Elastic License; -// you may not use this file except in compliance with the Elastic License. - -package browser - -import ( - "context" - "fmt" - - "github.com/elastic/beats/v7/libbeat/common" -) - -type JourneyLister func(ctx context.Context, suitePath string, params common.MapStr) (journeyNames []string, err error) - -var journeyListSingleton JourneyLister - -type SyntheticSuite struct { - rawCfg *common.Config - suiteCfg *Config -} - -func NewSuite(rawCfg *common.Config) (*SyntheticSuite, error) { - ss := &SyntheticSuite{ - rawCfg: rawCfg, - suiteCfg: DefaultConfig(), - } - err := rawCfg.Unpack(ss.suiteCfg) - if err != nil { - return nil, ErrBadConfig(err) - } - - return ss, nil -} - -func ErrBadConfig(err error) error { - return fmt.Errorf("could not parse suite config: %w", err) -} - -func (s *SyntheticSuite) String() string { - panic("implement me") -} - -func (s *SyntheticSuite) Fetch() error { - return s.suiteCfg.Source.Active().Fetch() -} - -func (s *SyntheticSuite) Workdir() string { - return s.suiteCfg.Source.Active().Workdir() -} - -func (s *SyntheticSuite) InlineSource() (string, bool) { - if s.suiteCfg.Source.Inline != nil { - return s.suiteCfg.Source.Inline.Script, true - } - return "", false -} - -func (s *SyntheticSuite) Params() map[string]interface{} { - return s.suiteCfg.Params -} - -func (s *SyntheticSuite) Close() error { - if s.suiteCfg.Source.ActiveMemo != nil { - s.suiteCfg.Source.ActiveMemo.Close() - } - - return nil -} diff --git a/x-pack/heartbeat/monitors/browser/suite_runner_test.go b/x-pack/heartbeat/monitors/browser/suite_test.go similarity index 76% rename from x-pack/heartbeat/monitors/browser/suite_runner_test.go rename to x-pack/heartbeat/monitors/browser/suite_test.go index 9f9448440cca..c583492d39d6 100644 --- a/x-pack/heartbeat/monitors/browser/suite_runner_test.go +++ b/x-pack/heartbeat/monitors/browser/suite_test.go @@ -7,6 +7,7 @@ package browser import ( "path" "path/filepath" + "reflect" "runtime" "testing" @@ -114,3 +115,42 @@ func TestEmptySource(t *testing.T) { require.Regexp(t, ErrBadConfig(source.ErrInvalidSource), e) require.Nil(t, s) } + +func TestExtraArgs(t *testing.T) { + tests := []struct { + name string + cfg *Config + want []string + }{ + { + "no args", + &Config{}, + nil, + }, + { + "sandbox", + &Config{Sandbox: true}, + []string{"--sandbox"}, + }, + { + "capabilities", + &Config{SyntheticsArgs: []string{"--capability", "trace", "ssblocks"}}, + []string{"--capability", "trace", "ssblocks"}, + }, + { + "kitchen sink", + &Config{SyntheticsArgs: []string{"--capability", "trace", "ssblocks"}, Sandbox: true}, + []string{"--capability", "trace", "ssblocks", "--sandbox"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &Suite{ + suiteCfg: tt.cfg, + } + if got := s.extraArgs(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Suite.extraArgs() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/x-pack/heartbeat/monitors/browser/synthexec/enrich.go b/x-pack/heartbeat/monitors/browser/synthexec/enrich.go index 4e3e05e21705..eda6fbedba65 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/enrich.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/enrich.go @@ -8,6 +8,7 @@ import ( "fmt" "time" + "github.com/elastic/beats/v7/libbeat/beat/events" "github.com/elastic/beats/v7/libbeat/processors/add_data_stream_index" "github.com/gofrs/uuid" @@ -108,11 +109,21 @@ func (je *journeyEnricher) enrichSynthEvent(event *beat.Event, se *SynthEvent) e case "step/end": je.stepCount++ case "step/screenshot": + fallthrough + case "step/screenshot_ref": + fallthrough + case "screenshot/block": add_data_stream_index.SetEventDataset(event, "browser_screenshot") case "journey/network_info": add_data_stream_index.SetEventDataset(event, "browser_network") } + if se.Id != "" { + event.SetID(se.Id) + // This is only relevant for screenshots, which have a specific ID + // In that case we always want to issue an update op + event.Meta.Put(events.FieldMetaOpType, events.OpTypeCreate) + } eventext.MergeEventFields(event, se.ToMap()) if je.urlFields == nil { diff --git a/x-pack/heartbeat/monitors/browser/synthexec/enrich_test.go b/x-pack/heartbeat/monitors/browser/synthexec/enrich_test.go index 61d9167eea86..83c5af37b28d 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/enrich_test.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/enrich_test.go @@ -13,9 +13,10 @@ import ( "github.com/stretchr/testify/require" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" - "github.com/elastic/beats/v7/libbeat/beat" + "github.com/elastic/beats/v7/libbeat/beat/events" "github.com/elastic/beats/v7/libbeat/common" + "github.com/elastic/beats/v7/libbeat/processors/add_data_stream_index" "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/testslike" ) @@ -111,3 +112,86 @@ func TestJourneyEnricher(t *testing.T) { }) } } + +func TestEnrichSynthEvent(t *testing.T) { + tests := []struct { + name string + je *journeyEnricher + se *SynthEvent + wantErr bool + check func(t *testing.T, e *beat.Event, je *journeyEnricher) + }{ + { + "journey/end", + &journeyEnricher{}, + &SynthEvent{Type: "journey/end"}, + false, + func(t *testing.T, e *beat.Event, je *journeyEnricher) { + v := lookslike.MustCompile(map[string]interface{}{ + "summary": map[string]int{ + "up": 1, + "down": 0, + }, + }) + testslike.Test(t, v, e.Fields) + }, + }, + { + "step/end", + &journeyEnricher{}, + &SynthEvent{Type: "step/end"}, + false, + func(t *testing.T, e *beat.Event, je *journeyEnricher) { + require.Equal(t, 1, je.stepCount) + }, + }, + { + "step/screenshot", + &journeyEnricher{}, + &SynthEvent{Type: "step/screenshot"}, + false, + func(t *testing.T, e *beat.Event, je *journeyEnricher) { + require.Equal(t, "browser_screenshot", e.Meta[add_data_stream_index.FieldMetaCustomDataset]) + }, + }, + { + "step/screenshot_ref", + &journeyEnricher{}, + &SynthEvent{Type: "step/screenshot_ref"}, + false, + func(t *testing.T, e *beat.Event, je *journeyEnricher) { + require.Equal(t, "browser_screenshot", e.Meta[add_data_stream_index.FieldMetaCustomDataset]) + }, + }, + { + "step/screenshot_block", + &journeyEnricher{}, + &SynthEvent{Type: "screenshot/block", Id: "my_id"}, + false, + func(t *testing.T, e *beat.Event, je *journeyEnricher) { + require.Equal(t, "my_id", e.Meta["_id"]) + require.Equal(t, events.OpTypeCreate, e.Meta[events.FieldMetaOpType]) + require.Equal(t, "browser_screenshot", e.Meta[add_data_stream_index.FieldMetaCustomDataset]) + }, + }, + { + "journey/network_info", + &journeyEnricher{}, + &SynthEvent{Type: "journey/network_info"}, + false, + func(t *testing.T, e *beat.Event, je *journeyEnricher) { + require.Equal(t, "browser_network", e.Meta[add_data_stream_index.FieldMetaCustomDataset]) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + e := &beat.Event{} + if err := tt.je.enrichSynthEvent(e, tt.se); (err != nil) != tt.wantErr { + t.Errorf("journeyEnricher.enrichSynthEvent() error = %v, wantErr %v", err, tt.wantErr) + } + tt.check(t, e, tt.je) + }) + } +} diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go b/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go index b251010cbb9a..c26f138ab238 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go @@ -30,7 +30,7 @@ const debugSelector = "synthexec" func SuiteJob(ctx context.Context, suitePath string, params common.MapStr, extraArgs ...string) (jobs.Job, error) { // Run the command in the given suitePath, use '.' as the first arg since the command runs // in the correct dir - newCmd, err := suiteCommandFactory(suitePath, append(extraArgs, ".", "--screenshots")...) + newCmd, err := suiteCommandFactory(suitePath, append(extraArgs, ".")...) if err != nil { return nil, err } @@ -57,7 +57,7 @@ func suiteCommandFactory(suitePath string, args ...string) (func() *exec.Cmd, er // InlineJourneyJob returns a job that runs the given source as a single journey. func InlineJourneyJob(ctx context.Context, script string, params common.MapStr, extraArgs ...string) jobs.Job { newCmd := func() *exec.Cmd { - return exec.Command("elastic-synthetics", append(extraArgs, "--inline", "--screenshots")...) + return exec.Command("elastic-synthetics", append(extraArgs, "--inline")...) } return startCmdJob(ctx, newCmd, &script, params) @@ -110,21 +110,20 @@ func runCmd( // Common args cmd.Env = append(os.Environ(), "NODE_ENV=production") - // We need to pass both files in here otherwise we get a broken pipe, even - // though node only touches the writer - cmd.ExtraFiles = []*os.File{jsonWriter, jsonReader} - cmd.Args = append(cmd.Args, - // Out fd is always 3 since it's the only FD passed into cmd.ExtraFiles - // see the docs for ExtraFiles in https://golang.org/pkg/os/exec/#Cmd - "--json", - "--network", - "--outfd", "3", - ) + cmd.Args = append(cmd.Args, "--rich-events") + if len(params) > 0 { paramsBytes, _ := json.Marshal(params) cmd.Args = append(cmd.Args, "--suite-params", string(paramsBytes)) } + // We need to pass both files in here otherwise we get a broken pipe, even + // though node only touches the writer + cmd.ExtraFiles = []*os.File{jsonWriter, jsonReader} + // Out fd is always 3 since it's the only FD passed into cmd.ExtraFiles + // see the docs for ExtraFiles in https://golang.org/pkg/os/exec/#Cmd + cmd.Args = append(cmd.Args, "--outfd", "3") + logp.Info("Running command: %s in directory: '%s'", cmd.String(), cmd.Dir) if stdinStr != nil { @@ -168,9 +167,6 @@ func runCmd( // Close mpx after the process is done and all events have been sent / consumed go func() { err := cmd.Wait() - if err != nil { - logp.Err("Error waiting for command %s: %s", cmd.String(), err) - } jsonWriter.Close() jsonReader.Close() logp.Info("Command has completed(%d): %s", cmd.ProcessState.ExitCode(), cmd.String()) diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go index 40cf2e062426..8b2bd8785972 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go @@ -16,6 +16,7 @@ import ( ) type SynthEvent struct { + Id string `json:"_id"` Type string `json:"type"` PackageVersion string `json:"package_version"` Step *Step `json:"step"` From 7bd96c2b0d7ba56863b46c4208a7c2b30efcf7d0 Mon Sep 17 00:00:00 2001 From: Andrew Wilkins Date: Tue, 8 Jun 2021 12:26:23 +0800 Subject: [PATCH 07/26] libbeat/idxmgmt/ilm: fix alias creation (#26146) When creating the initial index/write alias fails, don't check the status code, just check if the alias exists regardless of the error. This fixes a bug where alias creation fails when the alias exists but points to another index, and the initial index does not exist (e.g. due to ILM deletion.) --- CHANGELOG.next.asciidoc | 1 + libbeat/idxmgmt/ilm/client_handler.go | 17 +++++----- .../ilm/client_handler_integration_test.go | 33 ++++++++++++++++++- 3 files changed, 41 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 365f7f96ef58..fe5d08099d80 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -239,6 +239,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix 'make setup' instructions for a new beat {pull}24944[24944] - Fix out of date FreeBSD vagrantbox. {pull}25652[25652] - Fix handling of `file_selectors` in aws-s3 input. {pull}25792[25792] +- Fix ILM alias creation when write alias exists and initial index does not exist {pull}26143[26143] - Include date separator in the filename prefix of `dateRotator` to make sure nothing gets purged accidentally {pull}26176[26176] *Auditbeat* diff --git a/libbeat/idxmgmt/ilm/client_handler.go b/libbeat/idxmgmt/ilm/client_handler.go index 12b739c99467..d17af457ef46 100644 --- a/libbeat/idxmgmt/ilm/client_handler.go +++ b/libbeat/idxmgmt/ilm/client_handler.go @@ -191,19 +191,18 @@ func (h *ESClientHandler) CreateAlias(alias Alias) error { } // Note: actual aliases are accessible via the index - status, res, err := h.client.Request("PUT", "/"+firstIndex, "", nil, body) - if status == 400 { - // HasAlias fails if there is an index with the same name, that is - // what we want to check here. - _, err := h.HasAlias(alias.Name) - if err != nil { + if _, res, err := h.client.Request("PUT", "/"+firstIndex, "", nil, body); err != nil { + // Creating the index may fail for multiple reasons, e.g. because + // the index exists, or because the write alias exists and points + // to another index. + if ok, err := h.HasAlias(alias.Name); err != nil { + // HasAlias fails if there is an index with the same name. return err + } else if ok { + return errOf(ErrAliasAlreadyExists) } - return errOf(ErrAliasAlreadyExists) - } else if err != nil { return wrapErrf(err, ErrAliasCreateFailed, "failed to create alias: %s", res) } - return nil } diff --git a/libbeat/idxmgmt/ilm/client_handler_integration_test.go b/libbeat/idxmgmt/ilm/client_handler_integration_test.go index 936eb35dcd81..9471da7c9cfb 100644 --- a/libbeat/idxmgmt/ilm/client_handler_integration_test.go +++ b/libbeat/idxmgmt/ilm/client_handler_integration_test.go @@ -136,13 +136,44 @@ func TestESClientHandler_Alias(t *testing.T) { assert.True(t, b) }) - t.Run("second create", func(t *testing.T) { + t.Run("create index exists", func(t *testing.T) { alias := makeAlias("esch-alias-2create") h := newESClientHandler(t) err := h.CreateAlias(alias) assert.NoError(t, err) + // Second time around creating the alias, ErrAliasAlreadyExists is returned: + // the initial index already exists and the write alias points to it. + err = h.CreateAlias(alias) + require.Error(t, err) + assert.Equal(t, ilm.ErrAliasAlreadyExists, ilm.ErrReason(err)) + + b, err := h.HasAlias(alias.Name) + assert.NoError(t, err) + assert.True(t, b) + }) + + t.Run("create alias exists", func(t *testing.T) { + alias := makeAlias("esch-alias-2create") + alias.Pattern = "000001" // no date math, so we get predictable index names + h := newESClientHandler(t) + + err := h.CreateAlias(alias) + assert.NoError(t, err) + + // Rollover, so write alias points at -000002. + es := newRawESClient(t) + _, _, err = es.Request("POST", "/"+alias.Name+"/_rollover", "", nil, nil) + require.NoError(t, err) + + // Delete -000001, simulating ILM delete. + _, _, err = es.Request("DELETE", "/"+alias.Name+"-"+alias.Pattern, "", nil, nil) + require.NoError(t, err) + + // Second time around creating the alias, ErrAliasAlreadyExists is returned: + // initial index does not exist, but the write alias exists and points to + // another index. err = h.CreateAlias(alias) require.Error(t, err) assert.Equal(t, ilm.ErrAliasAlreadyExists, ilm.ErrReason(err)) From a3b642b55950c061a61732e5c8eef41e37d94b82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?No=C3=A9mi=20V=C3=A1nyi?= Date: Tue, 8 Jun 2021 13:32:00 +0200 Subject: [PATCH 08/26] Make `filestream` input GA (#26127) --- CHANGELOG.next.asciidoc | 1 + filebeat/_meta/config/filebeat.inputs.reference.yml.tmpl | 2 +- filebeat/_meta/config/filebeat.inputs.yml.tmpl | 2 +- filebeat/docs/inputs/input-filestream.asciidoc | 2 -- filebeat/filebeat.reference.yml | 2 +- filebeat/filebeat.yml | 2 +- filebeat/input/filestream/input.go | 2 +- x-pack/filebeat/filebeat.reference.yml | 2 +- x-pack/filebeat/filebeat.yml | 2 +- 9 files changed, 8 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index fe5d08099d80..16fd11b3a3bf 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -814,6 +814,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Update PanOS module to parse HIP Match logs. {issue}24350[24350] {pull}25686[25686] - Enhance GCP module to populate orchestrator.* fields for GKE / K8S logs {pull}25368[25368] - http_endpoint: Support multiple documents in a single request by POSTing an array or NDJSON format. {pull}25764[25764] +- Make `filestream` input GA. {pull}26127[26127] *Heartbeat* diff --git a/filebeat/_meta/config/filebeat.inputs.reference.yml.tmpl b/filebeat/_meta/config/filebeat.inputs.reference.yml.tmpl index 4986887155df..c5f22eaaad2c 100644 --- a/filebeat/_meta/config/filebeat.inputs.reference.yml.tmpl +++ b/filebeat/_meta/config/filebeat.inputs.reference.yml.tmpl @@ -11,7 +11,7 @@ filebeat.inputs: # # Possible options are: # * log: Reads every line of the log file (default) -# * filestream: Improved version of log input. Experimental. +# * filestream: Improved version of log input # * stdin: Reads the standard in #------------------------------ Log input -------------------------------- diff --git a/filebeat/_meta/config/filebeat.inputs.yml.tmpl b/filebeat/_meta/config/filebeat.inputs.yml.tmpl index 70d52cbb9c6a..2555aa26577b 100644 --- a/filebeat/_meta/config/filebeat.inputs.yml.tmpl +++ b/filebeat/_meta/config/filebeat.inputs.yml.tmpl @@ -50,7 +50,7 @@ filebeat.inputs: # Note: After is the equivalent to previous and before is the equivalent to to next in Logstash #multiline.match: after -# filestream is an experimental input. It is going to replace log input in the future. +# filestream is an input for collecting log messages from files. It is going to replace log input in the future. - type: filestream # Change to true to enable this input configuration. diff --git a/filebeat/docs/inputs/input-filestream.asciidoc b/filebeat/docs/inputs/input-filestream.asciidoc index 6634b97ac6ff..d43e39928c44 100644 --- a/filebeat/docs/inputs/input-filestream.asciidoc +++ b/filebeat/docs/inputs/input-filestream.asciidoc @@ -3,8 +3,6 @@ [id="{beatname_lc}-input-{type}"] === filestream input -beta[] - ++++ filestream ++++ diff --git a/filebeat/filebeat.reference.yml b/filebeat/filebeat.reference.yml index 09d1c85e51b9..9710b7a61112 100644 --- a/filebeat/filebeat.reference.yml +++ b/filebeat/filebeat.reference.yml @@ -418,7 +418,7 @@ filebeat.inputs: # # Possible options are: # * log: Reads every line of the log file (default) -# * filestream: Improved version of log input. Experimental. +# * filestream: Improved version of log input # * stdin: Reads the standard in #------------------------------ Log input -------------------------------- diff --git a/filebeat/filebeat.yml b/filebeat/filebeat.yml index 390305dd34bf..87521d1df447 100644 --- a/filebeat/filebeat.yml +++ b/filebeat/filebeat.yml @@ -62,7 +62,7 @@ filebeat.inputs: # Note: After is the equivalent to previous and before is the equivalent to to next in Logstash #multiline.match: after -# filestream is an experimental input. It is going to replace log input in the future. +# filestream is an input for collecting log messages from files. It is going to replace log input in the future. - type: filestream # Change to true to enable this input configuration. diff --git a/filebeat/input/filestream/input.go b/filebeat/input/filestream/input.go index 90563b2e309c..8294baa85d2d 100644 --- a/filebeat/input/filestream/input.go +++ b/filebeat/input/filestream/input.go @@ -64,7 +64,7 @@ type filestream struct { func Plugin(log *logp.Logger, store loginp.StateStore) input.Plugin { return input.Plugin{ Name: pluginName, - Stability: feature.Beta, + Stability: feature.Stable, Deprecated: false, Info: "filestream input", Doc: "The filestream input collects logs from the local filestream service", diff --git a/x-pack/filebeat/filebeat.reference.yml b/x-pack/filebeat/filebeat.reference.yml index 3a89edfe1aa4..f712a3f7e0e5 100644 --- a/x-pack/filebeat/filebeat.reference.yml +++ b/x-pack/filebeat/filebeat.reference.yml @@ -2442,7 +2442,7 @@ filebeat.inputs: # # Possible options are: # * log: Reads every line of the log file (default) -# * filestream: Improved version of log input. Experimental. +# * filestream: Improved version of log input # * stdin: Reads the standard in #------------------------------ Log input -------------------------------- diff --git a/x-pack/filebeat/filebeat.yml b/x-pack/filebeat/filebeat.yml index 390305dd34bf..87521d1df447 100644 --- a/x-pack/filebeat/filebeat.yml +++ b/x-pack/filebeat/filebeat.yml @@ -62,7 +62,7 @@ filebeat.inputs: # Note: After is the equivalent to previous and before is the equivalent to to next in Logstash #multiline.match: after -# filestream is an experimental input. It is going to replace log input in the future. +# filestream is an input for collecting log messages from files. It is going to replace log input in the future. - type: filestream # Change to true to enable this input configuration. From 689a746e3b2c80c628dcfd50d1a6bfce4cee1559 Mon Sep 17 00:00:00 2001 From: Michel Laterman <82832767+michel-laterman@users.noreply.github.com> Date: Tue, 8 Jun 2021 09:04:34 -0700 Subject: [PATCH 09/26] Chane fleetmode detection to ony use management.enabled (#26180) Fleetmode detection has been changed ton only use the enabled flag as fleet is now the only management mode available. --- libbeat/common/fleetmode/fleet_mode.go | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/libbeat/common/fleetmode/fleet_mode.go b/libbeat/common/fleetmode/fleet_mode.go index 6d0ce0224a5e..0349e05fdf72 100644 --- a/libbeat/common/fleetmode/fleet_mode.go +++ b/libbeat/common/fleetmode/fleet_mode.go @@ -25,11 +25,10 @@ import ( // Enabled checks to see if filebeat/metricbeat is running under Agent // The management setting is stored in the main Beat runtime object, but we can't see that from a module -// So instead we check the CLI flags, since Agent starts filebeat/metricbeat with "-E", "management.mode=x-pack-fleet", "-E", "management.enabled=true" +// So instead we check the CLI flags, since Agent starts filebeat/metricbeat with "-E", "management.enabled=true" func Enabled() bool { type management struct { - Mode string `config:"management.mode"` - Enabled bool `config:"management.enabled"` + Enabled bool `config:"management.enabled"` } var managementSettings management @@ -46,8 +45,5 @@ func Enabled() bool { return false } - if managementSettings.Enabled == true && managementSettings.Mode == "x-pack-fleet" { - return true - } - return false + return managementSettings.Enabled } From f71a0d21604f4d914d6bd02a9d50c95097ed5737 Mon Sep 17 00:00:00 2001 From: Pier-Hugues Pellerin Date: Tue, 8 Jun 2021 14:29:24 -0400 Subject: [PATCH 10/26] Remove 32 bits version of Elastic Agent. (#25708) --- x-pack/elastic-agent/CHANGELOG.asciidoc | 1 + x-pack/elastic-agent/magefile.go | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/x-pack/elastic-agent/CHANGELOG.asciidoc b/x-pack/elastic-agent/CHANGELOG.asciidoc index 16e9fd671ce5..ba7686a7ccdb 100644 --- a/x-pack/elastic-agent/CHANGELOG.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.asciidoc @@ -12,6 +12,7 @@ - Remove obfuscation of fleet.yml, causes re-enroll of agent to Fleet {pull}19678[19678] - Rename enroll --ca_sha256 to --ca-sha256 {pull}19900[19900] - Rename enroll --certificate_authorities to --certificate-authorities {pull}19900[19900] +- Don't build 32 bits version of Elastic Agent. {issue}25533[25533] ==== Bugfixes diff --git a/x-pack/elastic-agent/magefile.go b/x-pack/elastic-agent/magefile.go index 0ece510c1836..2ccd1dfb5b5d 100644 --- a/x-pack/elastic-agent/magefile.go +++ b/x-pack/elastic-agent/magefile.go @@ -58,6 +58,7 @@ func init() { devtools.BeatDescription = "Agent manages other beats based on configuration provided." devtools.BeatLicense = "Elastic License" + devtools.Platforms = devtools.NewPlatformList("!linux/386 !windows/386") } // Default set to build everything by default. @@ -303,10 +304,8 @@ func Package() { packages string }{ {"darwin/amd64", "darwin-x86_64.tar.gz"}, - {"linux/386", "linux-x86.tar.gz"}, {"linux/amd64", "linux-x86_64.tar.gz"}, {"linux/arm64", "linux-arm64.tar.gz"}, - {"windows/386", "windows-x86.zip"}, {"windows/amd64", "windows-x86_64.zip"}, } From 5a294a461f3681112eccf4c438740764f187104c Mon Sep 17 00:00:00 2001 From: Michal Pristas Date: Tue, 8 Jun 2021 21:38:23 +0200 Subject: [PATCH 11/26] Fix startup with failing configuration (#26126) Fix startup with failing configuration (#26126) --- x-pack/elastic-agent/CHANGELOG.next.asciidoc | 1 + .../pkg/agent/operation/operation_config.go | 9 ++- .../pkg/core/plugin/process/app.go | 64 +++++++++++++++++-- .../pkg/core/plugin/process/start.go | 35 ++++++++-- .../pkg/core/plugin/process/status.go | 30 ++++++--- 5 files changed, 117 insertions(+), 22 deletions(-) diff --git a/x-pack/elastic-agent/CHANGELOG.next.asciidoc b/x-pack/elastic-agent/CHANGELOG.next.asciidoc index 9b7a1f5d29d2..584b2a8985ab 100644 --- a/x-pack/elastic-agent/CHANGELOG.next.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.next.asciidoc @@ -68,6 +68,7 @@ - Handle case where policy doesn't contain Fleet connection information {pull}25707[25707] - Fix fleet-server.yml spec to not overwrite existing keys {pull}25741[25741] - Agent sends wrong log level to Endpoint {issue}25583[25583] +- Fix startup with failing configuration {pull}26057[26057] - Change timestamp in elatic-agent-json.log to use UTC {issue}25391[25391] ==== New features diff --git a/x-pack/elastic-agent/pkg/agent/operation/operation_config.go b/x-pack/elastic-agent/pkg/agent/operation/operation_config.go index b8c56257aca6..00c365a61665 100644 --- a/x-pack/elastic-agent/pkg/agent/operation/operation_config.go +++ b/x-pack/elastic-agent/pkg/agent/operation/operation_config.go @@ -10,6 +10,7 @@ import ( "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/agent/configuration" "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/agent/errors" "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/logger" + "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/plugin/process" "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/state" ) @@ -53,7 +54,13 @@ func (o *operationConfig) Check(_ context.Context, _ Application) (bool, error) func (o *operationConfig) Run(ctx context.Context, application Application) (err error) { defer func() { if err != nil { - application.SetState(state.Failed, err.Error(), nil) + // application failed to apply config but is running. + s := state.Degraded + if errors.Is(err, process.ErrAppNotRunning) { + s = state.Failed + } + + application.SetState(s, err.Error(), nil) } }() return application.Configure(ctx, o.cfg) diff --git a/x-pack/elastic-agent/pkg/core/plugin/process/app.go b/x-pack/elastic-agent/pkg/core/plugin/process/app.go index c0c6341cbd31..635d4e370d51 100644 --- a/x-pack/elastic-agent/pkg/core/plugin/process/app.go +++ b/x-pack/elastic-agent/pkg/core/plugin/process/app.go @@ -30,6 +30,7 @@ import ( var ( // ErrAppNotRunning is returned when configuration is performed on not running application. ErrAppNotRunning = errors.New("application is not running", errors.TypeApplication) + procExitTimeout = 10 * time.Second ) // Application encapsulates a concrete application ran by elastic-agent e.g Beat. @@ -47,6 +48,7 @@ type Application struct { tag app.Taggable state state.State reporter state.Reporter + watchClosers map[int]context.CancelFunc uid int gid int @@ -105,6 +107,7 @@ func NewApplication( uid: uid, gid: gid, statusReporter: statusController.RegisterApp(id, appName), + watchClosers: make(map[int]context.CancelFunc), }, nil } @@ -159,6 +162,8 @@ func (a *Application) Stop() { a.srvState = nil if a.state.ProcessInfo != nil { + // stop and clean watcher + a.stopWatcher(a.state.ProcessInfo) if err := a.state.ProcessInfo.Process.Signal(stopSig); err == nil { // no error on signal, so wait for it to stop _, _ = a.state.ProcessInfo.Process.Wait() @@ -192,33 +197,52 @@ func (a *Application) watch(ctx context.Context, p app.Taggable, proc *process.I case ps := <-a.waitProc(proc.Process): procState = ps case <-a.bgContext.Done(): - a.Stop() + return + case <-ctx.Done(): + // closer called return } a.appLock.Lock() + defer a.appLock.Unlock() if a.state.ProcessInfo != proc { // already another process started, another watcher is watching instead - a.appLock.Unlock() + gracefulKill(proc) + return + } + + // stop the watcher + a.stopWatcher(a.state.ProcessInfo) + + // was already stopped by Stop, do not restart + if a.state.Status == state.Stopped { return } + a.state.ProcessInfo = nil srvState := a.srvState if srvState == nil || srvState.Expected() == proto.StateExpected_STOPPING { - a.appLock.Unlock() return } msg := fmt.Sprintf("exited with code: %d", procState.ExitCode()) - a.setState(state.Crashed, msg, nil) + a.setState(state.Restarting, msg, nil) // it was a crash - a.start(ctx, p, cfg) - a.appLock.Unlock() + a.start(ctx, p, cfg, true) }() } +func (a *Application) stopWatcher(procInfo *process.Info) { + if procInfo != nil { + if closer, ok := a.watchClosers[procInfo.PID]; ok { + closer() + delete(a.watchClosers, procInfo.PID) + } + } +} + func (a *Application) waitProc(proc *os.Process) <-chan *os.ProcessState { resChan := make(chan *os.ProcessState) @@ -250,3 +274,31 @@ func (a *Application) setState(s state.Status, msg string, payload map[string]in func (a *Application) cleanUp() { a.monitor.Cleanup(a.desc.Spec(), a.pipelineID) } + +func gracefulKill(proc *process.Info) { + if proc == nil || proc.Process == nil { + return + } + + // send stop signal to request stop + proc.Stop() + + var wg sync.WaitGroup + doneChan := make(chan struct{}) + wg.Add(1) + go func() { + wg.Done() + _, _ = proc.Process.Wait() + close(doneChan) + }() + + // wait for awaiter + wg.Wait() + + // kill in case it's still running after timeout + select { + case <-doneChan: + case <-time.After(procExitTimeout): + _ = proc.Process.Kill() + } +} diff --git a/x-pack/elastic-agent/pkg/core/plugin/process/start.go b/x-pack/elastic-agent/pkg/core/plugin/process/start.go index f87c439c011b..60792649da0d 100644 --- a/x-pack/elastic-agent/pkg/core/plugin/process/start.go +++ b/x-pack/elastic-agent/pkg/core/plugin/process/start.go @@ -26,11 +26,11 @@ func (a *Application) Start(ctx context.Context, t app.Taggable, cfg map[string] a.appLock.Lock() defer a.appLock.Unlock() - return a.start(ctx, t, cfg) + return a.start(ctx, t, cfg, false) } // Start starts the application without grabbing the lock. -func (a *Application) start(ctx context.Context, t app.Taggable, cfg map[string]interface{}) (err error) { +func (a *Application) start(ctx context.Context, t app.Taggable, cfg map[string]interface{}, isRestart bool) (err error) { defer func() { if err != nil { // inject App metadata @@ -38,8 +38,25 @@ func (a *Application) start(ctx context.Context, t app.Taggable, cfg map[string] } }() - // already started if not stopped or crashed - if a.Started() { + // starting only if it's not running + // or if it is, then only in case it's restart and this call initiates from restart call + if a.Started() && a.state.Status != state.Restarting { + if a.state.ProcessInfo == nil { + // already started if not stopped or crashed + return nil + } + + // in case app reported status it might still be running and failure timer + // in progress. Stop timer and stop failing process + a.stopFailedTimer() + a.stopWatcher(a.state.ProcessInfo) + + // kill the process + _ = a.state.ProcessInfo.Process.Kill() + a.state.ProcessInfo = nil + } + + if a.state.Status == state.Restarting && !isRestart { return nil } @@ -69,7 +86,8 @@ func (a *Application) start(ctx context.Context, t app.Taggable, cfg map[string] if a.state.Status != state.Stopped { // restarting as it was previously in a different state a.setState(state.Restarting, "Restarting", nil) - } else { + } else if a.state.Status != state.Restarting { + // keep restarting state otherwise it's starting a.setState(state.Starting, "Starting", nil) } @@ -116,12 +134,15 @@ func (a *Application) start(ctx context.Context, t app.Taggable, cfg map[string] if err != nil { return err } - // write connect info to stdin go a.writeToStdin(a.srvState, a.state.ProcessInfo.Stdin) + // create closer for watcher, used to terminate watcher without + // side effect of restarting process during shutdown + cancelCtx, cancel := context.WithCancel(ctx) + a.watchClosers[a.state.ProcessInfo.PID] = cancel // setup watcher - a.watch(ctx, t, a.state.ProcessInfo, cfg) + a.watch(cancelCtx, t, a.state.ProcessInfo, cfg) return nil } diff --git a/x-pack/elastic-agent/pkg/core/plugin/process/status.go b/x-pack/elastic-agent/pkg/core/plugin/process/status.go index 02c38d6b82d3..c335b3b64468 100644 --- a/x-pack/elastic-agent/pkg/core/plugin/process/status.go +++ b/x-pack/elastic-agent/pkg/core/plugin/process/status.go @@ -13,6 +13,7 @@ import ( "github.com/elastic/elastic-agent-client/v7/pkg/proto" + "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/process" "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/server" "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/state" ) @@ -42,7 +43,8 @@ func (a *Application) OnStatusChange(s *server.ApplicationState, status proto.St _ = yaml.Unmarshal([]byte(s.Config()), &cfg) // start the failed timer - a.startFailedTimer(cfg) + // pass process info to avoid killing new process spun up in a meantime + a.startFailedTimer(cfg, a.state.ProcessInfo) } else { a.stopFailedTimer() } @@ -51,7 +53,7 @@ func (a *Application) OnStatusChange(s *server.ApplicationState, status proto.St // startFailedTimer starts a timer that will restart the application if it doesn't exit failed after a period of time. // // This does not grab the appLock, that must be managed by the caller. -func (a *Application) startFailedTimer(cfg map[string]interface{}) { +func (a *Application) startFailedTimer(cfg map[string]interface{}, proc *process.Info) { if a.restartCanceller != nil { // already have running failed timer; just update config a.restartConfig = cfg @@ -74,7 +76,7 @@ func (a *Application) startFailedTimer(cfg map[string]interface{}) { case <-ctx.Done(): return case <-t.C: - a.restart() + a.restart(proc) } }() } @@ -91,19 +93,31 @@ func (a *Application) stopFailedTimer() { } // restart restarts the application -func (a *Application) restart() { +func (a *Application) restart(proc *process.Info) { a.appLock.Lock() defer a.appLock.Unlock() + // stop the watcher + a.stopWatcher(proc) + // kill the process - if a.state.ProcessInfo != nil { - _ = a.state.ProcessInfo.Process.Kill() - a.state.ProcessInfo = nil + if proc != nil && proc.Process != nil { + _ = proc.Process.Kill() + } + + if proc != a.state.ProcessInfo { + // we're restarting different process than actually running + // no need to start another one + return } + + a.state.ProcessInfo = nil + ctx := a.startContext tag := a.tag - err := a.start(ctx, tag, a.restartConfig) + a.setState(state.Restarting, "", nil) + err := a.start(ctx, tag, a.restartConfig, true) if err != nil { a.setState(state.Crashed, fmt.Sprintf("failed to restart: %s", err), nil) } From 7bcea0e9bf7e1418c505025268a4e6fd5663c501 Mon Sep 17 00:00:00 2001 From: kaiyan-sheng Date: Wed, 9 Jun 2021 08:40:47 +0800 Subject: [PATCH 12/26] Disable test processors system test for windows 10 (#26216) --- metricbeat/tests/system/test_lightmodules.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/metricbeat/tests/system/test_lightmodules.py b/metricbeat/tests/system/test_lightmodules.py index 96986ba68c92..e39262295de7 100644 --- a/metricbeat/tests/system/test_lightmodules.py +++ b/metricbeat/tests/system/test_lightmodules.py @@ -2,6 +2,7 @@ import metricbeat import os import os.path +import platform import shutil import sys import threading @@ -12,6 +13,8 @@ class Test(metricbeat.BaseTest): + @unittest.skipIf(platform.platform().startswith("Windows-10"), + "flaky test: https://github.com/elastic/beats/issues/26181") def test_processors(self): shutil.copytree( os.path.join(self.beat_path, "mb/testing/testdata/lightmodules"), From dbde7dbf7508f0467463fad2905ed333ced912d3 Mon Sep 17 00:00:00 2001 From: Toby McLaughlin Date: Wed, 9 Jun 2021 16:39:25 +0930 Subject: [PATCH 13/26] [Metricbeat] Add state_statefulset replicas.ready (#26088) Add a "replicas.ready" field to the state_statefulset metricset of the Kubernetes module. This is drawn from the "readyReplicas" value in the Kubernetes StatefulSetStatus API response. --- CHANGELOG.next.asciidoc | 1 + metricbeat/docs/fields.asciidoc | 10 ++++++++++ metricbeat/module/kubernetes/fields.go | 2 +- .../kubernetes/state_statefulset/_meta/data.json | 3 ++- .../kubernetes/state_statefulset/_meta/fields.yml | 4 ++++ .../state_statefulset/_meta/test/ksm.v1.8.0.expected | 3 ++- .../state_statefulset/_meta/testdata/docs.plain | 5 +++++ .../_meta/testdata/docs.plain-expected.json | 9 ++++++--- .../kubernetes/state_statefulset/state_statefulset.go | 1 + 9 files changed, 32 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 16fd11b3a3bf..3bc81d095fae 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -132,6 +132,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add support for the MemoryPressure, DiskPressure, OutOfDisk and PIDPressure status conditions in state_node. {pull}23905[23905] - Remove xpack enabled flag on ES, Logstash, Beats and Kibana {pull}24427[24427] - Adjust host fields to adopt new names from 1.9.0 ECS. {pull}24312[24312] +- Add replicas.ready field to state_statefulset in Kubernetes module{pull}26088[26088] *Packetbeat* diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index ad89ed74cefd..710ef15ec459 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -37274,6 +37274,16 @@ type: long The number of desired replicas per StatefulSet +type: long + +-- + +*`kubernetes.statefulset.replicas.ready`*:: ++ +-- +The number of ready replicas per StatefulSet + + type: long -- diff --git a/metricbeat/module/kubernetes/fields.go b/metricbeat/module/kubernetes/fields.go index 7908d15cd7c4..80b4d4bc4410 100644 --- a/metricbeat/module/kubernetes/fields.go +++ b/metricbeat/module/kubernetes/fields.go @@ -32,5 +32,5 @@ func init() { // AssetKubernetes returns asset data. // This is the base64 encoded gzipped contents of module/kubernetes. func AssetKubernetes() string { - return "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" + return "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" } diff --git a/metricbeat/module/kubernetes/state_statefulset/_meta/data.json b/metricbeat/module/kubernetes/state_statefulset/_meta/data.json index 27291f2f43ec..776b4a48d937 100644 --- a/metricbeat/module/kubernetes/state_statefulset/_meta/data.json +++ b/metricbeat/module/kubernetes/state_statefulset/_meta/data.json @@ -16,7 +16,8 @@ "name": "mysql", "replicas": { "desired": 5, - "observed": 2 + "observed": 2, + "ready": 2 } } }, diff --git a/metricbeat/module/kubernetes/state_statefulset/_meta/fields.yml b/metricbeat/module/kubernetes/state_statefulset/_meta/fields.yml index 9c4997997302..20cd01d8d15c 100644 --- a/metricbeat/module/kubernetes/state_statefulset/_meta/fields.yml +++ b/metricbeat/module/kubernetes/state_statefulset/_meta/fields.yml @@ -21,6 +21,10 @@ type: long description: > The number of desired replicas per StatefulSet + - name: ready + type: long + description: > + The number of ready replicas per StatefulSet - name: generation type: group description: > diff --git a/metricbeat/module/kubernetes/state_statefulset/_meta/test/ksm.v1.8.0.expected b/metricbeat/module/kubernetes/state_statefulset/_meta/test/ksm.v1.8.0.expected index 1c3e98de2f15..a5c1c584229d 100644 --- a/metricbeat/module/kubernetes/state_statefulset/_meta/test/ksm.v1.8.0.expected +++ b/metricbeat/module/kubernetes/state_statefulset/_meta/test/ksm.v1.8.0.expected @@ -13,7 +13,8 @@ "name": "web", "replicas": { "desired": 2, - "observed": 2 + "observed": 2, + "ready": 2 } }, "Index": "", diff --git a/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain b/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain index 32b7edd31e05..ee71c2d18576 100644 --- a/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain +++ b/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain @@ -462,3 +462,8 @@ kube_statefulset_status_observed_generation{namespace="custom",statefulset="mysq kube_statefulset_status_replicas{namespace="default",statefulset="elasticsearch"} 1 kube_statefulset_status_replicas{namespace="default",statefulset="mysql"} 2 kube_statefulset_status_replicas{namespace="custom",statefulset="mysql"} 3 +# HELP kube_statefulset_status_replicas_ready The number of ready replicas per StatefulSet. +# TYPE kube_statefulset_status_replicas_ready gauge +kube_statefulset_status_replicas_ready{namespace="default",statefulset="elasticsearch"} 1 +kube_statefulset_status_replicas_ready{namespace="default",statefulset="mysql"} 2 +kube_statefulset_status_replicas_ready{namespace="custom",statefulset="mysql"} 1 diff --git a/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain-expected.json b/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain-expected.json index a2d37b446ed7..ae850efe365f 100644 --- a/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain-expected.json +++ b/metricbeat/module/kubernetes/state_statefulset/_meta/testdata/docs.plain-expected.json @@ -16,7 +16,8 @@ "name": "mysql", "replicas": { "desired": 5, - "observed": 2 + "observed": 2, + "ready": 2 } } }, @@ -46,7 +47,8 @@ "name": "elasticsearch", "replicas": { "desired": 4, - "observed": 1 + "observed": 1, + "ready": 1 } } }, @@ -76,7 +78,8 @@ "name": "mysql", "replicas": { "desired": 6, - "observed": 3 + "observed": 3, + "ready": 1 } } }, diff --git a/metricbeat/module/kubernetes/state_statefulset/state_statefulset.go b/metricbeat/module/kubernetes/state_statefulset/state_statefulset.go index eb59e4127f47..2bf221945380 100644 --- a/metricbeat/module/kubernetes/state_statefulset/state_statefulset.go +++ b/metricbeat/module/kubernetes/state_statefulset/state_statefulset.go @@ -47,6 +47,7 @@ var ( "kube_statefulset_status_observed_generation": p.Metric("generation.observed"), "kube_statefulset_replicas": p.Metric("replicas.desired"), "kube_statefulset_status_replicas": p.Metric("replicas.observed"), + "kube_statefulset_status_replicas_ready": p.Metric("replicas.ready"), }, Labels: map[string]p.LabelMap{ From e2449afc63d55914adf2aeb4e05721b792ce6159 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?No=C3=A9mi=20V=C3=A1nyi?= Date: Wed, 9 Jun 2021 12:44:59 +0200 Subject: [PATCH 14/26] Add new parser to filestream input: container (#26115) ## What does this PR do? This PR adds support for a new parser named `container`. This is the reader that powers the `container` input behind the scenes. Now it is exposed as a parser. Example configuration for reading container logs with the `filesteam` input: ```yaml type: filestream paths: - /path/to/containers/*/*.log parsers: - container: ~ ``` ### Limitations The PR does not provide feature parity with the `container` input because of the lack of support for separating the states of stdout and strerr streams. It is coming in a follow-up PR. ## Why is it important? It is a step toward supporting reading container logs from every input that supports `parsers` option. --- CHANGELOG.next.asciidoc | 1 + .../input-filestream-reader-options.asciidoc | 26 ++++ filebeat/input/filestream/parser.go | 15 +++ filebeat/input/filestream/parser_test.go | 120 ++++++++++++++++++ libbeat/reader/readjson/docker_json.go | 27 ++++ libbeat/reader/readjson/docker_json_config.go | 101 +++++++++++++++ 6 files changed, 290 insertions(+) create mode 100644 libbeat/reader/readjson/docker_json_config.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 3bc81d095fae..8376d8f92b8d 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -816,6 +816,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Enhance GCP module to populate orchestrator.* fields for GKE / K8S logs {pull}25368[25368] - http_endpoint: Support multiple documents in a single request by POSTing an array or NDJSON format. {pull}25764[25764] - Make `filestream` input GA. {pull}26127[26127] +- Add new `parser` to `filestream` input: `container`. {pull}26115[26115] *Heartbeat* diff --git a/filebeat/docs/inputs/input-filestream-reader-options.asciidoc b/filebeat/docs/inputs/input-filestream-reader-options.asciidoc index 1a55c85277c0..b2c0fa2fb706 100644 --- a/filebeat/docs/inputs/input-filestream-reader-options.asciidoc +++ b/filebeat/docs/inputs/input-filestream-reader-options.asciidoc @@ -151,6 +151,7 @@ Available parsers: * `multiline` * `ndjson` +* `container` In this example, {beatname_uc} is reading multiline messages that consist of 3 lines and are encapsulated in single-line JSON objects. @@ -232,3 +233,28 @@ JSON document and stored in `@metadata._id` *`ignore_decoding_error`*:: An optional configuration setting that specifies if JSON decoding errors should be logged or not. If set to true, errors will not be logged. The default is false. + +[float] +===== `container` + +Use the `container` parser to extract information from containers log files. +It parses lines into common message lines, extracting timestamps too. + +*`stream`*:: Reads from the specified streams only: `all`, `stdout` or `stderr`. The default +is `all`. + +*`format`*:: Use the given format when parsing logs: `auto`, `docker` or `cri`. The +default is `auto`, it will automatically detect the format. To disable +autodetection set any of the other options. + +The following snippet configures {beatname_uc} to read the `stdout` stream from +all containers under the default Kubernetes logs path: + +[source,yaml] +---- + paths: + - "/var/log/containers/*.log" + parsers: + - container: + stream: stdout +---- diff --git a/filebeat/input/filestream/parser.go b/filebeat/input/filestream/parser.go index c64e2c19ee77..c64b8981ae4f 100644 --- a/filebeat/input/filestream/parser.go +++ b/filebeat/input/filestream/parser.go @@ -70,6 +70,14 @@ func newParsers(in reader.Reader, pCfg parserConfig, c []common.ConfigNamespace) return nil, fmt.Errorf("error while parsing ndjson parser config: %+v", err) } p = readjson.NewJSONParser(p, &config) + case "container": + config := readjson.DefaultContainerConfig() + cfg := ns.Config() + err := cfg.Unpack(&config) + if err != nil { + return nil, fmt.Errorf("error while parsing container parser config: %+v", err) + } + p = readjson.NewContainerParser(p, &config) default: return nil, fmt.Errorf("%s: %s", ErrNoSuchParser, name) } @@ -96,6 +104,13 @@ func validateParserConfig(pCfg parserConfig, c []common.ConfigNamespace) error { if err != nil { return fmt.Errorf("error while parsing ndjson parser config: %+v", err) } + case "container": + config := readjson.DefaultContainerConfig() + cfg := ns.Config() + err := cfg.Unpack(&config) + if err != nil { + return fmt.Errorf("error while parsing container parser config: %+v", err) + } default: return fmt.Errorf("%s: %s", ErrNoSuchParser, name) } diff --git a/filebeat/input/filestream/parser_test.go b/filebeat/input/filestream/parser_test.go index f363425eb12c..696729d1e317 100644 --- a/filebeat/input/filestream/parser_test.go +++ b/filebeat/input/filestream/parser_test.go @@ -258,6 +258,126 @@ func TestJSONParsersWithFields(t *testing.T) { } +func TestContainerParser(t *testing.T) { + tests := map[string]struct { + lines string + parsers map[string]interface{} + expectedMessages []reader.Message + }{ + "simple docker lines": { + lines: `{"log":"Fetching main repository github.com/elastic/beats...\n","stream":"stdout","time":"2016-03-02T22:58:51.338462311Z"} +{"log":"Fetching dependencies...\n","stream":"stdout","time":"2016-03-02T22:59:04.609292428Z"} +{"log":"Execute /scripts/packetbeat_before_build.sh\n","stream":"stdout","time":"2016-03-02T22:59:04.617434682Z"} +{"log":"patching file vendor/github.com/tsg/gopacket/pcap/pcap.go\n","stream":"stdout","time":"2016-03-02T22:59:04.626534779Z"} +`, + parsers: map[string]interface{}{ + "paths": []string{"dummy_path"}, + "parsers": []map[string]interface{}{ + map[string]interface{}{ + "container": map[string]interface{}{}, + }, + }, + }, + expectedMessages: []reader.Message{ + reader.Message{ + Content: []byte("Fetching main repository github.com/elastic/beats...\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + reader.Message{ + Content: []byte("Fetching dependencies...\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + reader.Message{ + Content: []byte("Execute /scripts/packetbeat_before_build.sh\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + reader.Message{ + Content: []byte("patching file vendor/github.com/tsg/gopacket/pcap/pcap.go\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + }, + }, + "CRI docker lines": { + lines: `2017-09-12T22:32:21.212861448Z stdout F 2017-09-12 22:32:21.212 [INFO][88] table.go 710: Invalidating dataplane cache +`, + parsers: map[string]interface{}{ + "paths": []string{"dummy_path"}, + "parsers": []map[string]interface{}{ + map[string]interface{}{ + "container": map[string]interface{}{ + "format": "cri", + }, + }, + }, + }, + expectedMessages: []reader.Message{ + reader.Message{ + Content: []byte("2017-09-12 22:32:21.212 [INFO][88] table.go 710: Invalidating dataplane cache\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + }, + }, + "corrupt docker lines are skipped": { + lines: `{"log":"Fetching main repository github.com/elastic/beats...\n","stream":"stdout","time":"2016-03-02T22:58:51.338462311Z"} +"log":"Fetching dependencies...\n","stream":"stdout","time":"2016-03-02T22:59:04.609292428Z"} +{"log":"Execute /scripts/packetbeat_before_build.sh\n","stream":"stdout","time":"2016-03-02T22:59:04.617434682Z"} +`, + parsers: map[string]interface{}{ + "paths": []string{"dummy_path"}, + "parsers": []map[string]interface{}{ + map[string]interface{}{ + "container": map[string]interface{}{}, + }, + }, + }, + expectedMessages: []reader.Message{ + reader.Message{ + Content: []byte("Fetching main repository github.com/elastic/beats...\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + reader.Message{ + Content: []byte("Execute /scripts/packetbeat_before_build.sh\n"), + Fields: common.MapStr{ + "stream": "stdout", + }, + }, + }, + }, + } + + for name, test := range tests { + test := test + t.Run(name, func(t *testing.T) { + cfg := defaultConfig() + parsersConfig := common.MustNewConfigFrom(test.parsers) + err := parsersConfig.Unpack(&cfg) + require.NoError(t, err) + + p, err := newParsers(testReader(test.lines), parserConfig{lineTerminator: readfile.AutoLineTerminator, maxBytes: 1024}, cfg.Reader.Parsers) + + i := 0 + msg, err := p.Next() + for err == nil { + require.Equal(t, test.expectedMessages[i].Content, msg.Content) + require.Equal(t, test.expectedMessages[i].Fields, msg.Fields) + i++ + msg, err = p.Next() + } + }) + } +} func testReader(lines string) reader.Reader { encF, _ := encoding.FindEncoding("") reader := strings.NewReader(lines) diff --git a/libbeat/reader/readjson/docker_json.go b/libbeat/reader/readjson/docker_json.go index d57c61c6a268..d182ed7a1874 100644 --- a/libbeat/reader/readjson/docker_json.go +++ b/libbeat/reader/readjson/docker_json.go @@ -87,6 +87,33 @@ func New(r reader.Reader, stream string, partial bool, format string, CRIFlags b return &reader } +func NewContainerParser(r reader.Reader, config *ContainerJSONConfig) *DockerJSONReader { + reader := DockerJSONReader{ + stream: config.Stream.String(), + partial: true, + reader: r, + criflags: true, + logger: logp.NewLogger("parser_container"), + } + + switch config.Format { + case Docker, JSONFile: + reader.parseLine = reader.parseDockerJSONLog + case CRI: + reader.parseLine = reader.parseCRILog + default: + reader.parseLine = reader.parseAuto + } + + if runtime.GOOS == "windows" { + reader.stripNewLine = stripNewLineWin + } else { + reader.stripNewLine = stripNewLine + } + + return &reader +} + // parseCRILog parses logs in CRI log format. // CRI log format example : // 2017-09-12T22:32:21.212861448Z stdout 2017-09-12 22:32:21.212 [INFO][88] table.go 710: Invalidating dataplane cache diff --git a/libbeat/reader/readjson/docker_json_config.go b/libbeat/reader/readjson/docker_json_config.go new file mode 100644 index 000000000000..53ec01d25f1d --- /dev/null +++ b/libbeat/reader/readjson/docker_json_config.go @@ -0,0 +1,101 @@ +// 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 readjson + +import "fmt" + +type ContainerFormat uint8 + +type Stream uint8 + +const ( + Auto ContainerFormat = iota + 1 + CRI + Docker + JSONFile + + All Stream = iota + 1 + Stdout + Stderr +) + +var ( + containerFormats = map[string]ContainerFormat{ + "auto": Auto, + "cri": CRI, + "docker": Docker, + "json-file": JSONFile, + } + + containerStreams = map[string]Stream{ + "all": All, + "stdout": Stdout, + "stderr": Stderr, + } +) + +type ContainerJSONConfig struct { + Stream Stream `config:"stream"` + Format ContainerFormat `config:"format"` +} + +func DefaultContainerConfig() ContainerJSONConfig { + return ContainerJSONConfig{ + Format: Auto, + Stream: All, + } +} + +func (f *ContainerFormat) Unpack(v string) error { + val, ok := containerFormats[v] + if !ok { + keys := make([]string, len(containerFormats)) + i := 0 + for k := range containerFormats { + keys[i] = k + i++ + } + return fmt.Errorf("unknown container log format: %s, supported values: %+v", v, keys) + } + *f = val + return nil +} + +func (s *Stream) Unpack(v string) error { + val, ok := containerStreams[v] + if !ok { + keys := make([]string, len(containerStreams)) + i := 0 + for k := range containerStreams { + keys[i] = k + i++ + } + return fmt.Errorf("unknown streams: %s, supported values: %+v", v, keys) + } + *s = val + return nil +} + +func (s *Stream) String() string { + for k, v := range containerStreams { + if v == *s { + return k + } + } + return "" +} From 383f689855086910652fe1ab69d529865cf515e9 Mon Sep 17 00:00:00 2001 From: Gil Raphaelli Date: Wed, 9 Jun 2021 09:05:40 -0400 Subject: [PATCH 15/26] libbeat: monitor version (#26214) --- CHANGELOG.next.asciidoc | 1 + .../cmd/instance/metrics/metrics_common.go | 2 ++ .../instance/metrics/metrics_common_test.go | 33 +++++++++++++++++++ libbeat/monitoring/report/log/log.go | 1 + 4 files changed, 37 insertions(+) create mode 100644 libbeat/cmd/instance/metrics/metrics_common_test.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 8376d8f92b8d..81bc3f92e9b8 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -592,6 +592,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Allow node/namespace metadata to be disabled on kubernetes metagen and ensure add_kubernetes_metadata honors host {pull}23012[23012] - Add support for defining explicitly named dynamic templates without path/type match criteria {pull}25422[25422] - Improve ES output error insights. {pull}25825[25825] +- Libbeat: report beat version to monitoring. {pull}26214[26214] *Auditbeat* diff --git a/libbeat/cmd/instance/metrics/metrics_common.go b/libbeat/cmd/instance/metrics/metrics_common.go index f9a4a2866c1d..1f76aa71c6ad 100644 --- a/libbeat/cmd/instance/metrics/metrics_common.go +++ b/libbeat/cmd/instance/metrics/metrics_common.go @@ -25,6 +25,7 @@ import ( "github.com/elastic/beats/v7/libbeat/logp" "github.com/elastic/beats/v7/libbeat/monitoring" "github.com/elastic/beats/v7/libbeat/monitoring/report/log" + "github.com/elastic/beats/v7/libbeat/version" ) var ( @@ -59,4 +60,5 @@ func reportInfo(_ monitoring.Mode, V monitoring.Visitor) { }) monitoring.ReportString(V, "ephemeral_id", ephemeralID.String()) + monitoring.ReportString(V, "version", version.GetDefaultVersion()) } diff --git a/libbeat/cmd/instance/metrics/metrics_common_test.go b/libbeat/cmd/instance/metrics/metrics_common_test.go new file mode 100644 index 000000000000..d5c6ce59132c --- /dev/null +++ b/libbeat/cmd/instance/metrics/metrics_common_test.go @@ -0,0 +1,33 @@ +// 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 metrics + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/elastic/beats/v7/libbeat/monitoring" + "github.com/elastic/beats/v7/libbeat/version" +) + +func TestMonitoring(t *testing.T) { + metrics := monitoring.Default.GetRegistry("beat") + metricsSnapshot := monitoring.CollectFlatSnapshot(metrics, monitoring.Full, true) + assert.Equal(t, version.GetDefaultVersion(), metricsSnapshot.Strings["info.version"]) +} diff --git a/libbeat/monitoring/report/log/log.go b/libbeat/monitoring/report/log/log.go index 2139f7cf978e..f05214cd932a 100644 --- a/libbeat/monitoring/report/log/log.go +++ b/libbeat/monitoring/report/log/log.go @@ -66,6 +66,7 @@ var gauges = map[string]bool{ // TODO: Change this when gauges are refactored, too. var strConsts = map[string]bool{ "beat.info.ephemeral_id": true, + "beat.info.version": true, } var ( From d97155072907d26eaa27707c038161767245f6ff Mon Sep 17 00:00:00 2001 From: Mariana Dima Date: Thu, 10 Jun 2021 09:58:46 +0200 Subject: [PATCH 16/26] Filebeat azure module pipeline fixes and changes (#26148) * fix for filbeat pipeline * changelog * fixes * retest * generate files * retest * fix tests * fix tests * update fields * update result * fix name * Format expected json files * sub * update fields * fix test Co-authored-by: Jaime Soriano Pastor --- CHANGELOG.next.asciidoc | 1 + filebeat/docs/fields.asciidoc | 29 +++-------- .../azure/activitylogs/_meta/fields.yml | 12 +---- .../azure/activitylogs/ingest/pipeline.yml | 29 ++++++++++- .../test/activitylogs_edgecases.log | 1 + .../activitylogs_edgecases.log-expected.json | 28 +++++++++++ .../azure/auditlogs/ingest/pipeline.yml | 41 ++++++++++++++++ .../module/azure/azure-shared-pipeline.yml | 48 ++++++++++++++++++- x-pack/filebeat/module/azure/fields.go | 2 +- .../azure/platformlogs/_meta/fields.yml | 9 ++-- .../azure/platformlogs/ingest/pipeline.yml | 27 +++++++---- .../test/platformlogs-eventhub.log | 2 +- .../platformlogs-eventhub.log-expected.json | 4 +- .../platformlogs/test/platformlogs-kube.log | 2 +- .../test/platformlogs-kube.log-expected.json | 5 +- .../azure/signinlogs/ingest/pipeline.yml | 12 ++++- 16 files changed, 189 insertions(+), 63 deletions(-) create mode 100644 x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log create mode 100644 x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log-expected.json diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 81bc3f92e9b8..3ec3a0d523e3 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -386,6 +386,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix `checkpoint.action_reason` when its a string, not a Long. {issue}25575[25575] {pull}25609[25609] - Fix `fortinet.firewall.addr` when its a string, not an IP address. {issue}25585[25585] {pull}25608[25608] - Fix incorrect field name appending to `related.hash` in `threatintel.abusechmalware` ingest pipeline. {issue}25151[25151] {pull}25674[25674] +- Add improvements to the azure activitylogs and platformlogs ingest pipelines. {pull}26148[26148] - Fix `kibana.log` pipeline when `event.duration` calculation becomes a Long. {issue}24556[24556] {pull}25675[25675] - o365: Avoid mapping exception for `Parameters` and `ExtendedProperties` fields of string type. {pull}26164[26164] diff --git a/filebeat/docs/fields.asciidoc b/filebeat/docs/fields.asciidoc index 2420347b952f..5d8321d6baa5 100644 --- a/filebeat/docs/fields.asciidoc +++ b/filebeat/docs/fields.asciidoc @@ -2675,30 +2675,13 @@ type: keyword -- -[float] -=== properties - -Properties - - - -*`azure.activitylogs.properties.service_request_id`*:: -+ --- -Service Request Id - - -type: keyword - --- - -*`azure.activitylogs.properties.status_code`*:: +*`azure.activitylogs.properties`*:: + -- -Status code +Properties -type: keyword +type: flattened -- @@ -3198,13 +3181,13 @@ type: keyword -- -*`azure.platformlogs.properties.*`*:: +*`azure.platformlogs.properties`*:: + -- -Properties +Event inner properties -type: object +type: flattened -- diff --git a/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml b/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml index 28ff5a06fd32..79dc3a152758 100644 --- a/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml @@ -104,16 +104,6 @@ description: > Event Category - name: properties - type: group + type: flattened description: > Properties - fields: - - name: service_request_id - type: keyword - description: > - Service Request Id - - name: status_code - type: keyword - description: > - Status code - diff --git a/x-pack/filebeat/module/azure/activitylogs/ingest/pipeline.yml b/x-pack/filebeat/module/azure/activitylogs/ingest/pipeline.yml index d9621f0694fc..bdf9f7d62edf 100644 --- a/x-pack/filebeat/module/azure/activitylogs/ingest/pipeline.yml +++ b/x-pack/filebeat/module/azure/activitylogs/ingest/pipeline.yml @@ -12,6 +12,11 @@ processors: params: empty_field_name: '"":"",' ignore_failure: true +- gsub: + field: message + pattern: "\\e" + replacement: "" + ignore_missing: true - json: field: message target_field: azure.activitylogs @@ -31,9 +36,17 @@ processors: field: azure.activitylogs.resourceId target_field: azure.resource_id ignore_missing: true -- rename: +- grok: + field: azure.activitylogs.callerIpAddress + patterns: + - \[%{IPORHOST:source.ip}\]:%{INT:source.port:int} + - "%{IPORHOST:source.ip}:%{INT:source.port:int}" + - "%{IPORHOST:source.ip}" + ignore_missing: true + ignore_failure: true +- remove: field: azure.activitylogs.callerIpAddress - target_field: source.ip + if: 'ctx.source?.ip != null' ignore_missing: true - set: field: client.ip @@ -63,6 +76,14 @@ processors: field: azure.activitylogs.location target_field: geo.name ignore_missing: true +- json: + field: azure.activitylogs.identity + if: "ctx.azure?.activitylogs?.identity instanceof String" + ignore_failure: true +- json: + field: azure.activitylogs.properties + if: "ctx.azure?.activitylogs?.properties instanceof String" + ignore_failure: true - script: lang: painless source: >- @@ -76,6 +97,10 @@ processors: ctx.azure.activitylogs.event_category = 'Administrative'; } ignore_failure: true +- remove: + field: azure.activitylogs.properties.eventCategory + if: 'ctx.azure.activitylogs.event_category != null' + ignore_missing: true - rename: field: azure.activitylogs.resultType target_field: azure.activitylogs.result_type diff --git a/x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log b/x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log new file mode 100644 index 000000000000..0aeb2d35c004 --- /dev/null +++ b/x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log @@ -0,0 +1 @@ +{"category":"ResourceHealth","correlationId":"1c867fe2-050c-4a74-bb1c-a83b15246fdd","level":"Information","operationName":"Microsoft.Resourcehealth/healthevent/Updated/action","properties":{"eventCategory":"ResourceHealth","eventProperties":{"cause":"PlatformInitiated"}},"resourceId":"/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.domainRegistration","resultType":"Updated","time":"2021-05-25T22:04:07.22Z"} diff --git a/x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log-expected.json b/x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log-expected.json new file mode 100644 index 000000000000..18dc9b1fc51f --- /dev/null +++ b/x-pack/filebeat/module/azure/activitylogs/test/activitylogs_edgecases.log-expected.json @@ -0,0 +1,28 @@ +[ + { + "@timestamp": "2021-05-25T22:04:07.220Z", + "azure.activitylogs.category": "ResourceHealth", + "azure.activitylogs.event_category": "ResourceHealth", + "azure.activitylogs.operation_name": "Microsoft.Resourcehealth/healthevent/Updated/action", + "azure.activitylogs.properties.eventProperties.cause": "PlatformInitiated", + "azure.activitylogs.result_type": "Updated", + "azure.correlation_id": "1c867fe2-050c-4a74-bb1c-a83b15246fdd", + "azure.resource.id": "/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.domainRegistration", + "azure.resource.provider": "Microsoft.domainRegistration", + "azure.subscription_id": "00000000-0000-0000-0000-000000000000", + "cloud.provider": "azure", + "event.action": "Microsoft.Resourcehealth/healthevent/Updated/action", + "event.dataset": "azure.activitylogs", + "event.kind": "event", + "event.module": "azure", + "event.original": "{\"category\":\"ResourceHealth\",\"correlationId\":\"1c867fe2-050c-4a74-bb1c-a83b15246fdd\",\"level\":\"Information\",\"operationName\":\"Microsoft.Resourcehealth/healthevent/Updated/action\",\"properties\":{\"eventCategory\":\"ResourceHealth\",\"eventProperties\":{\"cause\":\"PlatformInitiated\"}},\"resourceId\":\"/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.domainRegistration\",\"resultType\":\"Updated\",\"time\":\"2021-05-25T22:04:07.22Z\"}", + "fileset.name": "activitylogs", + "input.type": "log", + "log.level": "Information", + "log.offset": 0, + "service.type": "azure", + "tags": [ + "forwarded" + ] + } +] diff --git a/x-pack/filebeat/module/azure/auditlogs/ingest/pipeline.yml b/x-pack/filebeat/module/azure/auditlogs/ingest/pipeline.yml index 052fd9d69ae2..7816ccf97dc1 100644 --- a/x-pack/filebeat/module/azure/auditlogs/ingest/pipeline.yml +++ b/x-pack/filebeat/module/azure/auditlogs/ingest/pipeline.yml @@ -83,6 +83,27 @@ processors: field: azure.auditlogs.properties.additionalDetails target_field: azure.auditlogs.properties.additional_details ignore_missing: true +- grok: + field: azure.auditlogs.callerIpAddress + patterns: + - \[%{IPORHOST:source.ip}\]:%{INT:source.port:int} + - "%{IPORHOST:source.ip}:%{INT:source.port:int}" + - "%{IPORHOST:source.ip}" + ignore_missing: true + ignore_failure: true +- remove: + field: azure.auditlogs.callerIpAddress + if: 'ctx.source?.ip != null' + ignore_missing: true +- set: + field: client.ip + value: '{{source.ip}}' + ignore_empty_value: true +- append: + field: related.ip + value: '{{source.ip}}' + allow_duplicates: false + if: 'ctx.source?.ip != null' - rename: field: azure.auditlogs.properties.resultReason target_field: azure.auditlogs.properties.result_reason @@ -134,6 +155,26 @@ processors: field: azure.auditlogs.properties.initiatedBy target_field: azure.auditlogs.properties.initiated_by ignore_missing: true +- geoip: + field: source.ip + target_field: source.geo + ignore_missing: true +- geoip: + database_file: GeoLite2-ASN.mmdb + field: source.ip + target_field: source.as + properties: + - asn + - organization_name + ignore_missing: true +- rename: + field: source.as.asn + target_field: source.as.number + ignore_missing: true +- rename: + field: source.as.organization_name + target_field: source.as.organization.name + ignore_missing: true - set: field: event.kind value: event diff --git a/x-pack/filebeat/module/azure/azure-shared-pipeline.yml b/x-pack/filebeat/module/azure/azure-shared-pipeline.yml index e849758d3ad9..f2d59ae5fa14 100644 --- a/x-pack/filebeat/module/azure/azure-shared-pipeline.yml +++ b/x-pack/filebeat/module/azure/azure-shared-pipeline.yml @@ -7,6 +7,7 @@ processors: field: azure.resource_id patterns: - /SUBSCRIPTIONS/%{SUBID:azure.subscription_id}/RESOURCEGROUPS/%{GROUPID:azure.resource.group}/PROVIDERS/%{PROVIDERNAME:azure.resource.provider}/NAMESPACES/%{NAMESPACE:azure.resource.namespace}/AUTHORIZATIONRULES/%{RULE:azure.resource.authorization_rule} + - /subscriptions/%{SUBID:azure.subscription_id}/resourceGroups/%{GROUPID:azure.resource.group}/providers/%{PROVIDERNAME:azure.resource.provider}/namespaces/%{NAMESPACE:azure.resource.namespace}/authorizationRules/%{RULE:azure.resource.authorization_rule} pattern_definitions: SUBID: (\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1} GROUPID: .+ @@ -16,21 +17,66 @@ processors: ignore_failure: true - grok: field: azure.resource_id + if: 'ctx.azure?.subscription_id == null' patterns: - /SUBSCRIPTIONS/%{SUBID:azure.subscription_id}/RESOURCEGROUPS/%{GROUPID:azure.resource.group}/PROVIDERS/%{PROVIDERNAME:azure.resource.provider}/%{NAME:azure.resource.name} + - /subscriptions/%{SUBID:azure.subscription_id}/resourceGroups/%{GROUPID:azure.resource.group}/providers/%{PROVIDERNAME:azure.resource.provider}/%{NAME:azure.resource.name} pattern_definitions: SUBID: (\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1} GROUPID: .+ - PROVIDERNAME: ([A-Z])\w+.([A-Z])\w+/([A-Z])\w+. + PROVIDERNAME: ([A-Za-z])\w+.([A-Za-z])\w+/([A-Za-z])\w+. NAME: ((?!AUTHORIZATIONRULES).)*$ ignore_failure: true - grok: field: azure.resource_id + if: 'ctx.azure?.subscription_id == null' + patterns: + - /SUBSCRIPTIONS/%{SUBID:azure.subscription_id}/RESOURCEGROUPS/%{GROUPID:azure.resource.group}/PROVIDERS/%{PROVIDERNAME:azure.resource.provider}/%{NAME:azure.resource.name} + - /subscriptions/%{SUBID:azure.subscription_id}/resourceGroups/%{GROUPID:azure.resource.group}/providers/%{PROVIDERNAME:azure.resource.provider}/%{NAME:azure.resource.name} + pattern_definitions: + SUBID: (\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1} + GROUPID: .+ + PROVIDERNAME: ([A-Za-z])\w+.([A-Za-z])\w+\/([A-Za-z][^\/])\w+ + NAME: .+ + ignore_failure: true +- grok: + field: azure.resource_id + if: 'ctx.azure?.subscription_id == null' patterns: - /providers/%{PROVIDER:azure.resource.provider} + - /PROVIDERS/%{PROVIDER:azure.resource.provider} pattern_definitions: PROVIDER: .+ ignore_failure: true +- grok: + field: azure.resource_id + if: 'ctx.azure?.subscription_id == null' + patterns: + - /SUBSCRIPTIONS/%{SUBID:azure.subscription_id}/PROVIDERS/%{PROVIDERNAME:azure.resource.provider} + - /subscriptions/%{SUBID:azure.subscription_id}/providers/%{PROVIDERNAME:azure.resource.provider} + pattern_definitions: + SUBID: (\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1} + PROVIDERNAME: ([A-Za-z])\w+.([A-Za-z])\w+\/([A-Za-z][^\/])\w+ + ignore_failure: true +- grok: + field: azure.resource_id + if: 'ctx.azure?.subscription_id == null' + patterns: + - /SUBSCRIPTIONS/%{SUBID:azure.subscription_id}/RESOURCEGROUPS/%{GROUPID:azure.resource.group} + - /subscriptions/%{SUBID:azure.subscription_id}/resourceGroups/%{GROUPID:azure.resource.group} + pattern_definitions: + SUBID: (\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1} + GROUPID: .+ + ignore_failure: true +- grok: + field: azure.resource_id + if: 'ctx.azure?.subscription_id == null' + patterns: + - /SUBSCRIPTIONS/%{SUBID:azure.subscription_id} + - /subscriptions/%{SUBID:azure.subscription_id} + pattern_definitions: + SUBID: (\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1} + ignore_failure: true - rename: field: azure.resource_id target_field: azure.resource.id diff --git a/x-pack/filebeat/module/azure/fields.go b/x-pack/filebeat/module/azure/fields.go index d73cf818b099..c0709d753996 100644 --- a/x-pack/filebeat/module/azure/fields.go +++ b/x-pack/filebeat/module/azure/fields.go @@ -19,5 +19,5 @@ func init() { // AssetAzure returns asset data. // This is the base64 encoded gzipped contents of module/azure. func AssetAzure() string { - return "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" + return "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" } diff --git a/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml b/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml index ac03e0004f5b..c6560be390dc 100644 --- a/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml @@ -57,10 +57,7 @@ type: keyword description: > ActivityId - - name: properties.* - type: object - object_type: keyword - object_type_mapping_type: "*" + - name: properties + type: flattened description: > - Properties - + Event inner properties diff --git a/x-pack/filebeat/module/azure/platformlogs/ingest/pipeline.yml b/x-pack/filebeat/module/azure/platformlogs/ingest/pipeline.yml index 6d68736bc8b9..3ddb92eb6de2 100644 --- a/x-pack/filebeat/module/azure/platformlogs/ingest/pipeline.yml +++ b/x-pack/filebeat/module/azure/platformlogs/ingest/pipeline.yml @@ -51,17 +51,30 @@ processors: field: - azure.platformlogs.EventProperties ignore_missing: true -- rename: - field: azure.platformlogs.EventName - target_field: event.action - ignore_missing: true +- json: + field: azure.platformlogs.properties.log + target_field: azure.platformlogs.properties.log + ignore_failure: true - rename: field: azure.platformlogs.properties.log + if: "ctx.azure?.platformlogs?.properties?.log != null && ctx.azure?.platformlogs?.properties?.log instanceof String" target_field: message ignore_missing: true - rename: + field: azure.platformlogs.EventName + target_field: event.action + ignore_missing: true +- grok: field: azure.platformlogs.callerIpAddress - target_field: source.ip + patterns: + - \[%{IPORHOST:source.ip}\]:%{INT:source.port:int} + - "%{IPORHOST:source.ip}:%{INT:source.port:int}" + - "%{IPORHOST:source.ip}" + ignore_missing: true + ignore_failure: true +- remove: + field: azure.platformlogs.callerIpAddress + if: 'ctx.source?.ip != null' ignore_missing: true - set: field: client.ip @@ -174,10 +187,6 @@ processors: } def hm = new HashMap(params.get(ctx.azure.platformlogs.category.toLowerCase())); hm.forEach((k, v) -> ctx.event[k] = v); -- geoip: - field: source.ip - target_field: source.geo - ignore_missing: true - geoip: database_file: GeoLite2-ASN.mmdb field: source.ip diff --git a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log index 13f18cfe2c2f..31803c14b6df 100644 --- a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log +++ b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log @@ -1 +1 @@ -{"ActivityId":"30ed877c-a36b-491a-bd4d-ddd847fe55b8","Caller":"Portal","Environment":"PROD","EventName":"Retreive ConsumerGroup","EventProperties":"{\"SubscriptionId\":\"7657426d-c4c3-44ac-88a2-3b2cd59e6dba\",\"Namespace\":\"obstesteventhubs\",\"Via\":\"sb://obstesteventhubs.servicebus.windows.net/insights-logs-operationallogs/consumergroups?api-version=2017-04\u0026$skip=0\u0026$top=100\",\"TrackingId\":\"30ed877c-a36b-491a-bd4d-ddd847fe55b8_M2CH3_M2CH3_G3S2\"}","EventTimeString":"11/3/2020 9:06:42 AM +00:00","Region":"West Europe","ScaleUnit":"PROD-AM3-AZ501","Status":"Succeeded","category":"OperationalLogs","resourceId":"/SUBSCRIPTIONS/7657426D-C4C3-44AC-88A2-3B2CD59E6DBA/RESOURCEGROUPS/OBS-TEST/PROVIDERS/MICROSOFT.EVENTHUB/NAMESPACES/OBSTESTEVENTHUBS"} +{"ActivityId":"30ed877c-a36b-491a-bd4d-ddd847fe55b8","Caller":"Portal","Environment":"PROD","EventName":"Retreive ConsumerGroup","EventProperties":"{\"SubscriptionId\":\"7657426d-c4c3-44ac-88a2-3b2cd59e6dba\",\"Namespace\":\"obstesteventhubs\"}","EventTimeString":"11/3/2020 9:06:42 AM +00:00","Region":"West Europe","ScaleUnit":"PROD-AM3-AZ501","Status":"Succeeded","category":"OperationalLogs","resourceId":"/SUBSCRIPTIONS/7657426D-C4C3-44AC-88A2-3B2CD59E6DBA/RESOURCEGROUPS/OBS-TEST/PROVIDERS/MICROSOFT.EVENTHUB/NAMESPACES/OBSTESTEVENTHUBS"} diff --git a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log-expected.json b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log-expected.json index 4401b205a966..6ea13f58de30 100644 --- a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log-expected.json +++ b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-eventhub.log-expected.json @@ -10,8 +10,6 @@ "azure.platformlogs.event_category": "Administrative", "azure.platformlogs.properties.Namespace": "obstesteventhubs", "azure.platformlogs.properties.SubscriptionId": "7657426d-c4c3-44ac-88a2-3b2cd59e6dba", - "azure.platformlogs.properties.TrackingId": "30ed877c-a36b-491a-bd4d-ddd847fe55b8_M2CH3_M2CH3_G3S2", - "azure.platformlogs.properties.Via": "sb://obstesteventhubs.servicebus.windows.net/insights-logs-operationallogs/consumergroups?api-version=2017-04&$skip=0&$top=100", "azure.platformlogs.status": "Succeeded", "azure.resource.group": "OBS-TEST", "azure.resource.id": "/SUBSCRIPTIONS/7657426D-C4C3-44AC-88A2-3B2CD59E6DBA/RESOURCEGROUPS/OBS-TEST/PROVIDERS/MICROSOFT.EVENTHUB/NAMESPACES/OBSTESTEVENTHUBS", @@ -24,7 +22,7 @@ "event.dataset": "azure.platformlogs", "event.kind": "event", "event.module": "azure", - "event.original": "{\"ActivityId\":\"30ed877c-a36b-491a-bd4d-ddd847fe55b8\",\"Caller\":\"Portal\",\"Environment\":\"PROD\",\"EventName\":\"Retreive ConsumerGroup\",\"EventProperties\":\"{\\\"SubscriptionId\\\":\\\"7657426d-c4c3-44ac-88a2-3b2cd59e6dba\\\",\\\"Namespace\\\":\\\"obstesteventhubs\\\",\\\"Via\\\":\\\"sb://obstesteventhubs.servicebus.windows.net/insights-logs-operationallogs/consumergroups?api-version=2017-04\\u0026$skip=0\\u0026$top=100\\\",\\\"TrackingId\\\":\\\"30ed877c-a36b-491a-bd4d-ddd847fe55b8_M2CH3_M2CH3_G3S2\\\"}\",\"EventTimeString\":\"11/3/2020 9:06:42 AM +00:00\",\"Region\":\"West Europe\",\"ScaleUnit\":\"PROD-AM3-AZ501\",\"Status\":\"Succeeded\",\"category\":\"OperationalLogs\",\"resourceId\":\"/SUBSCRIPTIONS/7657426D-C4C3-44AC-88A2-3B2CD59E6DBA/RESOURCEGROUPS/OBS-TEST/PROVIDERS/MICROSOFT.EVENTHUB/NAMESPACES/OBSTESTEVENTHUBS\"}", + "event.original": "{\"ActivityId\":\"30ed877c-a36b-491a-bd4d-ddd847fe55b8\",\"Caller\":\"Portal\",\"Environment\":\"PROD\",\"EventName\":\"Retreive ConsumerGroup\",\"EventProperties\":\"{\\\"SubscriptionId\\\":\\\"7657426d-c4c3-44ac-88a2-3b2cd59e6dba\\\",\\\"Namespace\\\":\\\"obstesteventhubs\\\"}\",\"EventTimeString\":\"11/3/2020 9:06:42 AM +00:00\",\"Region\":\"West Europe\",\"ScaleUnit\":\"PROD-AM3-AZ501\",\"Status\":\"Succeeded\",\"category\":\"OperationalLogs\",\"resourceId\":\"/SUBSCRIPTIONS/7657426D-C4C3-44AC-88A2-3B2CD59E6DBA/RESOURCEGROUPS/OBS-TEST/PROVIDERS/MICROSOFT.EVENTHUB/NAMESPACES/OBSTESTEVENTHUBS\"}", "event.outcome": "succeeded", "fileset.name": "platformlogs", "input.type": "log", diff --git a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log index 7b8930fb3416..f0f58d19da58 100644 --- a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log +++ b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log @@ -1 +1 @@ -{"Cloud":"AzureCloud","Environment":"prod","category":"kube-audit","ccpNamespace":"5e4bf4baee195b00017cdbfa","operationName":"Microsoft.ContainerService/managedClusters/diagnosticLogs/Read","properties":{"log":"{\"kind\":\"Event\",\"apiVersion\":\"audit.k8s.io/v1\",\"level\":\"Metadata\",\"auditID\":\"22af12c3-a1fe-4f2c-99a9-3cdde671dbfe\"}","pod":"kube-apiserver-666bd4b459-hjgdc","stream":"stdout"},"resourceId":"/SUBSCRIPTIONS/70BD6E77-4B1E-4835-8896-DB77B8EEF364/RESOURCEGROUPS/OBS-INFRASTRUCTURE/PROVIDERS/MICROSOFT.CONTAINERSERVICE/MANAGEDCLUSTERS/OBSKUBE","time":"2020-11-09T10:57:31.0000000Z"} +{"Cloud":"AzureCloud","Environment":"prod","category":"kube-audit","ccpNamespace":"5e4bf4baee195b00017cdbfa","operationName":"Microsoft.ContainerService/managedClusters/diagnosticLogs/Read","properties":{"log":"{\"kind\":\"Event\"}","pod":"kube-apiserver-666bd4b459-hjgdc"},"resourceId":"/SUBSCRIPTIONS/70BD6E77-4B1E-4835-8896-DB77B8EEF364/RESOURCEGROUPS/OBS-INFRASTRUCTURE/PROVIDERS/MICROSOFT.CONTAINERSERVICE/MANAGEDCLUSTERS/OBSKUBE","time":"2020-11-09T10:57:31.0000000Z"} diff --git a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log-expected.json b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log-expected.json index 1e5b7cc84e35..3a940a2ba900 100644 --- a/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log-expected.json +++ b/x-pack/filebeat/module/azure/platformlogs/test/platformlogs-kube.log-expected.json @@ -7,8 +7,8 @@ "azure.platformlogs.ccpNamespace": "5e4bf4baee195b00017cdbfa", "azure.platformlogs.event_category": "Administrative", "azure.platformlogs.operation_name": "Microsoft.ContainerService/managedClusters/diagnosticLogs/Read", + "azure.platformlogs.properties.log.kind": "Event", "azure.platformlogs.properties.pod": "kube-apiserver-666bd4b459-hjgdc", - "azure.platformlogs.properties.stream": "stdout", "azure.resource.group": "OBS-INFRASTRUCTURE", "azure.resource.id": "/SUBSCRIPTIONS/70BD6E77-4B1E-4835-8896-DB77B8EEF364/RESOURCEGROUPS/OBS-INFRASTRUCTURE/PROVIDERS/MICROSOFT.CONTAINERSERVICE/MANAGEDCLUSTERS/OBSKUBE", "azure.resource.name": "OBSKUBE", @@ -19,11 +19,10 @@ "event.dataset": "azure.platformlogs", "event.kind": "event", "event.module": "azure", - "event.original": "{\"Cloud\":\"AzureCloud\",\"Environment\":\"prod\",\"category\":\"kube-audit\",\"ccpNamespace\":\"5e4bf4baee195b00017cdbfa\",\"operationName\":\"Microsoft.ContainerService/managedClusters/diagnosticLogs/Read\",\"properties\":{\"log\":\"{\\\"kind\\\":\\\"Event\\\",\\\"apiVersion\\\":\\\"audit.k8s.io/v1\\\",\\\"level\\\":\\\"Metadata\\\",\\\"auditID\\\":\\\"22af12c3-a1fe-4f2c-99a9-3cdde671dbfe\\\"}\",\"pod\":\"kube-apiserver-666bd4b459-hjgdc\",\"stream\":\"stdout\"},\"resourceId\":\"/SUBSCRIPTIONS/70BD6E77-4B1E-4835-8896-DB77B8EEF364/RESOURCEGROUPS/OBS-INFRASTRUCTURE/PROVIDERS/MICROSOFT.CONTAINERSERVICE/MANAGEDCLUSTERS/OBSKUBE\",\"time\":\"2020-11-09T10:57:31.0000000Z\"}", + "event.original": "{\"Cloud\":\"AzureCloud\",\"Environment\":\"prod\",\"category\":\"kube-audit\",\"ccpNamespace\":\"5e4bf4baee195b00017cdbfa\",\"operationName\":\"Microsoft.ContainerService/managedClusters/diagnosticLogs/Read\",\"properties\":{\"log\":\"{\\\"kind\\\":\\\"Event\\\"}\",\"pod\":\"kube-apiserver-666bd4b459-hjgdc\"},\"resourceId\":\"/SUBSCRIPTIONS/70BD6E77-4B1E-4835-8896-DB77B8EEF364/RESOURCEGROUPS/OBS-INFRASTRUCTURE/PROVIDERS/MICROSOFT.CONTAINERSERVICE/MANAGEDCLUSTERS/OBSKUBE\",\"time\":\"2020-11-09T10:57:31.0000000Z\"}", "fileset.name": "platformlogs", "input.type": "log", "log.offset": 0, - "message": "{\"kind\":\"Event\",\"apiVersion\":\"audit.k8s.io/v1\",\"level\":\"Metadata\",\"auditID\":\"22af12c3-a1fe-4f2c-99a9-3cdde671dbfe\"}", "service.type": "azure", "tags": [ "forwarded" diff --git a/x-pack/filebeat/module/azure/signinlogs/ingest/pipeline.yml b/x-pack/filebeat/module/azure/signinlogs/ingest/pipeline.yml index 800e7f01e60a..30499b36813e 100644 --- a/x-pack/filebeat/module/azure/signinlogs/ingest/pipeline.yml +++ b/x-pack/filebeat/module/azure/signinlogs/ingest/pipeline.yml @@ -28,9 +28,17 @@ processors: field: azure.signinlogs.resourceId target_field: azure.resource_id ignore_missing: true -- rename: +- grok: + field: azure.signinlogs.callerIpAddress + patterns: + - \[%{IPORHOST:source.ip}\]:%{INT:source.port:int} + - "%{IPORHOST:source.ip}:%{INT:source.port:int}" + - "%{IPORHOST:source.ip}" + ignore_missing: true + ignore_failure: true +- remove: field: azure.signinlogs.callerIpAddress - target_field: source.ip + if: 'ctx.source?.ip != null' ignore_missing: true - set: field: client.ip From 088464fd90b94b8b0ceb240eef8aa5868978f08d Mon Sep 17 00:00:00 2001 From: Mariana Dima Date: Thu, 10 Jun 2021 16:07:32 +0200 Subject: [PATCH 17/26] Move Filebeat azure module to GA (#26168) * remove beta from files * changelog * regenerate --- CHANGELOG.next.asciidoc | 1 + filebeat/docs/modules/azure.asciidoc | 2 -- x-pack/filebeat/module/azure/_meta/docs.asciidoc | 2 -- x-pack/filebeat/module/azure/_meta/fields.yml | 2 +- x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml | 2 +- x-pack/filebeat/module/azure/auditlogs/_meta/fields.yml | 1 + x-pack/filebeat/module/azure/fields.go | 2 +- x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml | 2 +- x-pack/filebeat/module/azure/signinlogs/_meta/fields.yml | 1 + 9 files changed, 7 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 3ec3a0d523e3..b8f9c5ebe730 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -816,6 +816,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add fingerprint processor to generate fixed ids for `google_workspace` events. {pull}25841[25841] - Update PanOS module to parse HIP Match logs. {issue}24350[24350] {pull}25686[25686] - Enhance GCP module to populate orchestrator.* fields for GKE / K8S logs {pull}25368[25368] +- Move Filebeat azure module to GA. {pull}26114[26114] {pull}26168[26168] - http_endpoint: Support multiple documents in a single request by POSTing an array or NDJSON format. {pull}25764[25764] - Make `filestream` input GA. {pull}26127[26127] - Add new `parser` to `filestream` input: `container`. {pull}26115[26115] diff --git a/filebeat/docs/modules/azure.asciidoc b/filebeat/docs/modules/azure.asciidoc index af8c24131856..e76362061159 100644 --- a/filebeat/docs/modules/azure.asciidoc +++ b/filebeat/docs/modules/azure.asciidoc @@ -10,8 +10,6 @@ This file is generated! See scripts/docs_collector.py == Azure module -beta[] - The azure module retrieves different types of log data from Azure. There are several requirements before using the module since the logs will actually be read from azure event hubs. diff --git a/x-pack/filebeat/module/azure/_meta/docs.asciidoc b/x-pack/filebeat/module/azure/_meta/docs.asciidoc index ee7c5961f85a..727349ac9c74 100644 --- a/x-pack/filebeat/module/azure/_meta/docs.asciidoc +++ b/x-pack/filebeat/module/azure/_meta/docs.asciidoc @@ -5,8 +5,6 @@ == Azure module -beta[] - The azure module retrieves different types of log data from Azure. There are several requirements before using the module since the logs will actually be read from azure event hubs. diff --git a/x-pack/filebeat/module/azure/_meta/fields.yml b/x-pack/filebeat/module/azure/_meta/fields.yml index 158ab823bf02..5211ffe028a3 100644 --- a/x-pack/filebeat/module/azure/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/_meta/fields.yml @@ -1,6 +1,6 @@ - key: azure title: "Azure" - release: beta + release: ga description: > Azure Module fields: diff --git a/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml b/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml index 79dc3a152758..0292cee520d8 100644 --- a/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/activitylogs/_meta/fields.yml @@ -1,6 +1,6 @@ - name: activitylogs type: group - release: beta + release: ga default_field: false description: > Fields for Azure activity logs. diff --git a/x-pack/filebeat/module/azure/auditlogs/_meta/fields.yml b/x-pack/filebeat/module/azure/auditlogs/_meta/fields.yml index e46892f11ecd..e45e27976c2c 100644 --- a/x-pack/filebeat/module/azure/auditlogs/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/auditlogs/_meta/fields.yml @@ -1,5 +1,6 @@ - name: auditlogs type: group + release: ga description: > Fields for Azure audit logs. default_field: false diff --git a/x-pack/filebeat/module/azure/fields.go b/x-pack/filebeat/module/azure/fields.go index c0709d753996..3a21083f45bf 100644 --- a/x-pack/filebeat/module/azure/fields.go +++ b/x-pack/filebeat/module/azure/fields.go @@ -19,5 +19,5 @@ func init() { // AssetAzure returns asset data. // This is the base64 encoded gzipped contents of module/azure. func AssetAzure() string { - return "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" + return "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" } diff --git a/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml b/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml index c6560be390dc..27aceeba5560 100644 --- a/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/platformlogs/_meta/fields.yml @@ -1,6 +1,6 @@ - name: platformlogs type: group - release: beta + release: ga default_field: false description: > Fields for Azure platform logs. diff --git a/x-pack/filebeat/module/azure/signinlogs/_meta/fields.yml b/x-pack/filebeat/module/azure/signinlogs/_meta/fields.yml index 63b542f02712..d5f1d7d8d290 100644 --- a/x-pack/filebeat/module/azure/signinlogs/_meta/fields.yml +++ b/x-pack/filebeat/module/azure/signinlogs/_meta/fields.yml @@ -1,5 +1,6 @@ - name: signinlogs type: group + release: ga description: > Fields for Azure sign-in logs. default_field: false From 7edb4579d1551292ec5f813be5de59b6a7340f1a Mon Sep 17 00:00:00 2001 From: weslambert Date: Thu, 10 Jun 2021 11:09:15 -0400 Subject: [PATCH 18/26] Add ISO8601 as supported timestamp type (#25564) * Add ISO8601 as supported timestamp type Co-authored-by: Lee E. Hinman --- CHANGELOG.next.asciidoc | 1 + .../zeek/capture_loss/ingest/pipeline.yml | 1 + .../zeek/connection/ingest/pipeline.yml | 1 + .../zeek/connection/test/connection-json.log | 1 + .../test/connection-json.log-expected.json | 55 +++++++++++++++++++ .../module/zeek/dce_rpc/ingest/pipeline.yml | 1 + .../module/zeek/dhcp/ingest/pipeline.yml | 1 + .../module/zeek/dnp3/ingest/pipeline.yml | 1 + .../module/zeek/dns/ingest/pipeline.yml | 1 + .../module/zeek/dpd/ingest/pipeline.yml | 1 + .../module/zeek/files/ingest/pipeline.yml | 1 + .../module/zeek/ftp/ingest/pipeline.yml | 1 + .../module/zeek/http/ingest/pipeline.yml | 1 + .../module/zeek/intel/ingest/pipeline.yml | 1 + .../module/zeek/irc/ingest/pipeline.yml | 1 + .../module/zeek/kerberos/ingest/pipeline.yml | 3 + .../module/zeek/modbus/ingest/pipeline.yml | 1 + .../module/zeek/mysql/ingest/pipeline.yml | 1 + .../module/zeek/notice/ingest/pipeline.yml | 1 + .../module/zeek/ntlm/ingest/pipeline.yml | 1 + .../module/zeek/ntp/ingest/pipeline.yml | 5 ++ .../module/zeek/ocsp/ingest/pipeline.yml | 4 ++ .../module/zeek/pe/ingest/pipeline.yml | 2 + .../module/zeek/radius/ingest/pipeline.yml | 1 + .../module/zeek/rdp/ingest/pipeline.yml | 1 + .../module/zeek/rfb/ingest/pipeline.yml | 1 + .../module/zeek/signature/ingest/pipeline.yml | 1 + .../module/zeek/sip/ingest/pipeline.yml | 1 + .../module/zeek/smb_cmd/ingest/pipeline.yml | 1 + .../module/zeek/smb_files/ingest/pipeline.yml | 5 ++ .../zeek/smb_mapping/ingest/pipeline.yml | 1 + .../module/zeek/smtp/ingest/pipeline.yml | 1 + .../module/zeek/snmp/ingest/pipeline.yml | 2 + .../module/zeek/socks/ingest/pipeline.yml | 1 + .../module/zeek/ssh/ingest/pipeline.yml | 1 + .../module/zeek/ssl/ingest/pipeline.yml | 3 + .../module/zeek/stats/ingest/pipeline.yml | 1 + .../module/zeek/syslog/ingest/pipeline.yml | 1 + .../zeek/traceroute/ingest/pipeline.yml | 1 + .../module/zeek/tunnel/ingest/pipeline.yml | 1 + .../module/zeek/weird/ingest/pipeline.yml | 1 + .../module/zeek/x509/ingest/pipeline.yml | 3 + 42 files changed, 115 insertions(+) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index b8f9c5ebe730..6be32d56ea13 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -820,6 +820,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - http_endpoint: Support multiple documents in a single request by POSTing an array or NDJSON format. {pull}25764[25764] - Make `filestream` input GA. {pull}26127[26127] - Add new `parser` to `filestream` input: `container`. {pull}26115[26115] +- Add support for ISO8601 timestamps in Zeek fileset {pull}25564[25564] *Heartbeat* diff --git a/x-pack/filebeat/module/zeek/capture_loss/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/capture_loss/ingest/pipeline.yml index 76e5178572e3..c1bd282d72dc 100644 --- a/x-pack/filebeat/module/zeek/capture_loss/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/capture_loss/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.capture_loss.ts formats: - UNIX + - ISO8601 - remove: field: zeek.capture_loss.ts - set: diff --git a/x-pack/filebeat/module/zeek/connection/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/connection/ingest/pipeline.yml index 93245720a06e..0eb015e15485 100644 --- a/x-pack/filebeat/module/zeek/connection/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/connection/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.connection.ts formats: - UNIX + - ISO8601 - remove: field: zeek.connection.ts - set: diff --git a/x-pack/filebeat/module/zeek/connection/test/connection-json.log b/x-pack/filebeat/module/zeek/connection/test/connection-json.log index 1275e552e3b7..467f28552c17 100644 --- a/x-pack/filebeat/module/zeek/connection/test/connection-json.log +++ b/x-pack/filebeat/module/zeek/connection/test/connection-json.log @@ -2,3 +2,4 @@ {"ts":1547188416.857497,"uid":"CAcJw21BbVedgFnYH4","id.orig_h":"192.168.86.167","id.orig_p":38340,"id.resp_h":"8.8.8.8","id.resp_p":53,"proto":"udp","service":"dns","duration":0.076967,"orig_bytes":75,"resp_bytes":178,"conn_state":"SF","local_orig":true,"local_resp":false,"missed_bytes":0,"history":"Dd","orig_pkts":1,"orig_ip_bytes":103,"resp_pkts":1,"resp_ip_bytes":206,"tunnel_parents":[]} {"ts":1547188417.857497,"uid":"CAcJw21BbVedgFnYH5","id.orig_h":"4.4.2.2","id.orig_p":38341,"id.resp_h":"8.8.8.8","id.resp_p":53,"proto":"udp","service":"dns","duration":0.076967,"orig_bytes":75,"resp_bytes":178,"conn_state":"SF","local_orig":false,"local_resp":false,"missed_bytes":0,"history":"Dd","orig_pkts":1,"orig_ip_bytes":103,"resp_pkts":1,"resp_ip_bytes":206,"tunnel_parents":[]} {"ts":1551399000.57855,"uid":"Cc6NJ3GRlfjE44I3h","id.orig_h":"192.0.2.205","id.orig_p":3,"id.resp_h":"198.51.100.249","id.resp_p":3,"proto":"icmp","conn_state":"OTH","local_orig":false,"local_resp":false,"missed_bytes":0,"orig_pkts":1,"orig_ip_bytes":107,"resp_pkts":0,"resp_ip_bytes":0,"tunnel_parents":[]} +{"ts":"2021-06-09T20:55:13.160328Z","uid":"C2KP1V3alRLoxl4JB9","id.orig_h":"10.0.2.15","id.orig_p":46408,"id.resp_h":"172.217.9.68","id.resp_p":80,"proto":"tcp","conn_state":"OTH","local_orig":true,"local_resp":false,"missed_bytes":0,"history":"C","orig_pkts":0,"orig_ip_bytes":0,"resp_pkts":0,"resp_ip_bytes":0} diff --git a/x-pack/filebeat/module/zeek/connection/test/connection-json.log-expected.json b/x-pack/filebeat/module/zeek/connection/test/connection-json.log-expected.json index 088aee7aedf4..ee6333827868 100644 --- a/x-pack/filebeat/module/zeek/connection/test/connection-json.log-expected.json +++ b/x-pack/filebeat/module/zeek/connection/test/connection-json.log-expected.json @@ -218,5 +218,60 @@ "zeek.connection.state": "OTH", "zeek.connection.state_message": "No SYN seen, just midstream traffic (a 'partial connection' that was not later closed).", "zeek.session_id": "Cc6NJ3GRlfjE44I3h" + }, + { + "@timestamp": "2021-06-09T20:55:13.160Z", + "destination.address": "172.217.9.68", + "destination.as.number": 15169, + "destination.as.organization.name": "Google LLC", + "destination.bytes": 0, + "destination.geo.continent_name": "North America", + "destination.geo.country_iso_code": "US", + "destination.geo.country_name": "United States", + "destination.geo.location.lat": 37.751, + "destination.geo.location.lon": -97.822, + "destination.ip": "172.217.9.68", + "destination.packets": 0, + "destination.port": 80, + "event.category": [ + "network" + ], + "event.dataset": "zeek.connection", + "event.id": "C2KP1V3alRLoxl4JB9", + "event.kind": "event", + "event.module": "zeek", + "event.type": [ + "connection", + "info" + ], + "fileset.name": "connection", + "input.type": "log", + "log.offset": 1488, + "network.bytes": 0, + "network.community_id": "1:DzqI9CYXjMSYV8VoSAHtMNfMIeU=", + "network.direction": "outbound", + "network.packets": 0, + "network.transport": "tcp", + "related.ip": [ + "10.0.2.15", + "172.217.9.68" + ], + "service.type": "zeek", + "source.address": "10.0.2.15", + "source.bytes": 0, + "source.ip": "10.0.2.15", + "source.packets": 0, + "source.port": 46408, + "tags": [ + "zeek.connection", + "local_orig" + ], + "zeek.connection.history": "C", + "zeek.connection.local_orig": true, + "zeek.connection.local_resp": false, + "zeek.connection.missed_bytes": 0, + "zeek.connection.state": "OTH", + "zeek.connection.state_message": "No SYN seen, just midstream traffic (a 'partial connection' that was not later closed).", + "zeek.session_id": "C2KP1V3alRLoxl4JB9" } ] \ No newline at end of file diff --git a/x-pack/filebeat/module/zeek/dce_rpc/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/dce_rpc/ingest/pipeline.yml index f0a837709dcf..cd3aa92da66b 100644 --- a/x-pack/filebeat/module/zeek/dce_rpc/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/dce_rpc/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.dce_rpc.ts formats: - UNIX + - ISO8601 - remove: field: zeek.dce_rpc.ts - append: diff --git a/x-pack/filebeat/module/zeek/dhcp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/dhcp/ingest/pipeline.yml index 49216c077c27..5bdf44d2c594 100644 --- a/x-pack/filebeat/module/zeek/dhcp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/dhcp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.dhcp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.dhcp.ts - set: diff --git a/x-pack/filebeat/module/zeek/dnp3/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/dnp3/ingest/pipeline.yml index e104312e1e13..071b22ff81bb 100644 --- a/x-pack/filebeat/module/zeek/dnp3/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/dnp3/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.dnp3.ts formats: - UNIX + - ISO8601 - remove: field: zeek.dnp3.ts - set: diff --git a/x-pack/filebeat/module/zeek/dns/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/dns/ingest/pipeline.yml index 6d9ed369ea89..58372aa2446f 100644 --- a/x-pack/filebeat/module/zeek/dns/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/dns/ingest/pipeline.yml @@ -12,6 +12,7 @@ processors: field: zeek.dns.ts formats: - UNIX + - ISO8601 - remove: field: zeek.dns.ts diff --git a/x-pack/filebeat/module/zeek/dpd/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/dpd/ingest/pipeline.yml index 32d1852c3e2c..9eeacd831679 100644 --- a/x-pack/filebeat/module/zeek/dpd/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/dpd/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.dpd.ts formats: - UNIX + - ISO8601 - remove: field: zeek.dpd.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/files/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/files/ingest/pipeline.yml index 754720e92095..c7b1d33ec9a6 100644 --- a/x-pack/filebeat/module/zeek/files/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/files/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.files.ts formats: - UNIX + - ISO8601 - remove: field: zeek.files.ts - script: diff --git a/x-pack/filebeat/module/zeek/ftp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/ftp/ingest/pipeline.yml index f1f7d0b4f522..52d08b15db92 100644 --- a/x-pack/filebeat/module/zeek/ftp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/ftp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.ftp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.ftp.ts - dot_expander: diff --git a/x-pack/filebeat/module/zeek/http/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/http/ingest/pipeline.yml index a2c4a85b9941..b4cc3baf6e4d 100644 --- a/x-pack/filebeat/module/zeek/http/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/http/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.http.ts formats: - UNIX + - ISO8601 - remove: field: zeek.http.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/intel/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/intel/ingest/pipeline.yml index f70094311318..1f193b4e22c3 100644 --- a/x-pack/filebeat/module/zeek/intel/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/intel/ingest/pipeline.yml @@ -11,6 +11,7 @@ processors: field: zeek.intel.ts formats: - UNIX + - ISO8601 - remove: field: zeek.intel.ts # IP Geolocation Lookup diff --git a/x-pack/filebeat/module/zeek/irc/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/irc/ingest/pipeline.yml index dd1e37a7035e..fb8c233bd256 100644 --- a/x-pack/filebeat/module/zeek/irc/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/irc/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.irc.ts formats: - UNIX + - ISO8601 - remove: field: zeek.irc.ts - append: diff --git a/x-pack/filebeat/module/zeek/kerberos/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/kerberos/ingest/pipeline.yml index e0f45f715850..b9c61080aa57 100644 --- a/x-pack/filebeat/module/zeek/kerberos/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/kerberos/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.kerberos.ts formats: - UNIX + - ISO8601 - remove: field: zeek.kerberos.ts - script: @@ -20,12 +21,14 @@ processors: target_field: zeek.kerberos.valid.until formats: - UNIX + - ISO8601 if: ctx.zeek.kerberos.valid?.until != null - date: field: zeek.kerberos.valid.from target_field: zeek.kerberos.valid.from formats: - UNIX + - ISO8601 if: ctx.zeek.kerberos.valid?.from != null - set: field: event.outcome diff --git a/x-pack/filebeat/module/zeek/modbus/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/modbus/ingest/pipeline.yml index d918b2de09a2..eadc215c31a1 100644 --- a/x-pack/filebeat/module/zeek/modbus/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/modbus/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.modbus.ts formats: - UNIX + - ISO8601 - remove: field: zeek.modbus.ts - append: diff --git a/x-pack/filebeat/module/zeek/mysql/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/mysql/ingest/pipeline.yml index d5552af6d29f..f0dcd1098c05 100644 --- a/x-pack/filebeat/module/zeek/mysql/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/mysql/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.mysql.ts formats: - UNIX + - ISO8601 - remove: field: zeek.mysql.ts - append: diff --git a/x-pack/filebeat/module/zeek/notice/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/notice/ingest/pipeline.yml index c741d355361f..b80566d66c6a 100644 --- a/x-pack/filebeat/module/zeek/notice/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/notice/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.notice.ts formats: - UNIX + - ISO8601 - remove: field: zeek.notice.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/ntlm/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/ntlm/ingest/pipeline.yml index 690fd54a54ba..ce950e49bda2 100644 --- a/x-pack/filebeat/module/zeek/ntlm/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/ntlm/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.ntlm.ts formats: - UNIX + - ISO8601 - remove: field: zeek.ntlm.ts - append: diff --git a/x-pack/filebeat/module/zeek/ntp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/ntp/ingest/pipeline.yml index ed603292a3d3..a93599c91d00 100644 --- a/x-pack/filebeat/module/zeek/ntp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/ntp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.ntp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.ntp.ts # IP Geolocation Lookup @@ -85,21 +86,25 @@ processors: target_field: zeek.ntp.ref_time formats: - UNIX + - ISO8601 - date: field: zeek.ntp.org_time target_field: zeek.ntp.org_time formats: - UNIX + - ISO8601 - date: field: zeek.ntp.rec_time target_field: zeek.ntp.rec_time formats: - UNIX + - ISO8601 - date: field: zeek.ntp.xmt_time target_field: zeek.ntp.xmt_time formats: - UNIX + - ISO8601 - convert: ignore_missing: true field: zeek.ntp.version diff --git a/x-pack/filebeat/module/zeek/ocsp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/ocsp/ingest/pipeline.yml index 462c1f366120..b4681a7637a6 100644 --- a/x-pack/filebeat/module/zeek/ocsp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/ocsp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.ocsp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.ocsp.ts - date: @@ -17,18 +18,21 @@ processors: target_field: zeek.ocsp.revoke.date formats: - UNIX + - ISO8601 if: ctx.zeek.ocsp.revoke?.date != null - date: field: zeek.ocsp.update.this target_field: zeek.ocsp.update.this formats: - UNIX + - ISO8601 if: ctx.zeek.ocsp.update?.this != null - date: field: zeek.ocsp.update.next target_field: zeek.ocsp.update.next formats: - UNIX + - ISO8601 if: ctx.zeek.ocsp.update?.next != null - append: field: related.hash diff --git a/x-pack/filebeat/module/zeek/pe/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/pe/ingest/pipeline.yml index 6e1272a8ab2a..08c1b27c294c 100644 --- a/x-pack/filebeat/module/zeek/pe/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/pe/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.pe.ts formats: - UNIX + - ISO8601 - remove: field: zeek.pe.ts - date: @@ -17,6 +18,7 @@ processors: target_field: zeek.pe.compile_time formats: - UNIX + - ISO8601 if: ctx.zeek.pe.compile_time != null on_failure: - set: diff --git a/x-pack/filebeat/module/zeek/radius/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/radius/ingest/pipeline.yml index acc7fad2f030..1736ed47656e 100644 --- a/x-pack/filebeat/module/zeek/radius/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/radius/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.radius.ts formats: - UNIX + - ISO8601 - remove: field: zeek.radius.ts - append: diff --git a/x-pack/filebeat/module/zeek/rdp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/rdp/ingest/pipeline.yml index bbe4abcee9fa..78aa132f9efa 100644 --- a/x-pack/filebeat/module/zeek/rdp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/rdp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.rdp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.rdp.ts - convert: diff --git a/x-pack/filebeat/module/zeek/rfb/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/rfb/ingest/pipeline.yml index 2ce5fda4e16b..4a3b6621e7ed 100644 --- a/x-pack/filebeat/module/zeek/rfb/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/rfb/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.rfb.ts formats: - UNIX + - ISO8601 - remove: field: zeek.rfb.ts - append: diff --git a/x-pack/filebeat/module/zeek/signature/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/signature/ingest/pipeline.yml index 539ea5d79121..5c35409d28dc 100644 --- a/x-pack/filebeat/module/zeek/signature/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/signature/ingest/pipeline.yml @@ -11,6 +11,7 @@ processors: field: zeek.signature.ts formats: - UNIX + - ISO8601 - remove: field: zeek.signature.ts # IP Geolocation Lookup diff --git a/x-pack/filebeat/module/zeek/sip/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/sip/ingest/pipeline.yml index 045d5afe760b..ddba53574cd8 100644 --- a/x-pack/filebeat/module/zeek/sip/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/sip/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.sip.ts formats: - UNIX + - ISO8601 - remove: field: zeek.sip.ts - grok: diff --git a/x-pack/filebeat/module/zeek/smb_cmd/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/smb_cmd/ingest/pipeline.yml index 0a853104351e..3034b1833307 100644 --- a/x-pack/filebeat/module/zeek/smb_cmd/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/smb_cmd/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.smb_cmd.ts formats: - UNIX + - ISO8601 - remove: field: zeek.smb_cmd.ts - remove: diff --git a/x-pack/filebeat/module/zeek/smb_files/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/smb_files/ingest/pipeline.yml index b1c0d3a69920..18ba31c60cb6 100644 --- a/x-pack/filebeat/module/zeek/smb_files/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/smb_files/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.smb_files.ts formats: - UNIX + - ISO8601 - remove: field: zeek.smb_files.ts - dot_expander: @@ -29,6 +30,7 @@ processors: target_field: zeek.smb_files.times.accessed formats: - UNIX + - ISO8601 if: ctx.zeek.smb_files.times?.accessed != null - set: field: file.accessed @@ -39,6 +41,7 @@ processors: target_field: zeek.smb_files.times.changed formats: - UNIX + - ISO8601 if: ctx.zeek.smb_files.times?.accessed != null - set: field: file.ctime @@ -49,6 +52,7 @@ processors: target_field: zeek.smb_files.times.created formats: - UNIX + - ISO8601 if: ctx.zeek.smb_files.times?.accessed != null - set: field: file.created @@ -59,6 +63,7 @@ processors: target_field: zeek.smb_files.times.modified formats: - UNIX + - ISO8601 if: ctx.zeek.smb_files.times?.accessed != null - set: field: file.mtime diff --git a/x-pack/filebeat/module/zeek/smb_mapping/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/smb_mapping/ingest/pipeline.yml index e116e1bfb600..15ed595d245b 100644 --- a/x-pack/filebeat/module/zeek/smb_mapping/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/smb_mapping/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.smb_mapping.ts formats: - UNIX + - ISO8601 - remove: field: zeek.smb_mapping.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/smtp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/smtp/ingest/pipeline.yml index 03e2ffb6a250..5cf3b12cf247 100644 --- a/x-pack/filebeat/module/zeek/smtp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/smtp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.smtp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.smtp.ts - date: diff --git a/x-pack/filebeat/module/zeek/snmp/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/snmp/ingest/pipeline.yml index 1aefc539733d..7fd305fab5ab 100644 --- a/x-pack/filebeat/module/zeek/snmp/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/snmp/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.snmp.ts formats: - UNIX + - ISO8601 - remove: field: zeek.snmp.ts - date: @@ -17,6 +18,7 @@ processors: target_field: zeek.snmp.up_since formats: - UNIX + - ISO8601 if: ctx.zeek.snmp.up_since != null - geoip: field: destination.ip diff --git a/x-pack/filebeat/module/zeek/socks/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/socks/ingest/pipeline.yml index e64c5ec9eb33..4f98ce007ab3 100644 --- a/x-pack/filebeat/module/zeek/socks/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/socks/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.socks.ts formats: - UNIX + - ISO8601 - remove: field: zeek.socks.ts - dot_expander: diff --git a/x-pack/filebeat/module/zeek/ssh/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/ssh/ingest/pipeline.yml index 26980d26f3da..7e943ae513af 100644 --- a/x-pack/filebeat/module/zeek/ssh/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/ssh/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.ssh.ts formats: - UNIX + - ISO8601 - remove: field: zeek.ssh.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/ssl/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/ssl/ingest/pipeline.yml index 4a980be985a2..eb7a25ca0265 100644 --- a/x-pack/filebeat/module/zeek/ssl/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/ssl/ingest/pipeline.yml @@ -11,6 +11,7 @@ processors: field: zeek.ssl.ts formats: - UNIX + - ISO8601 - remove: field: zeek.ssl.ts - date: @@ -19,12 +20,14 @@ processors: target_field: tls.server.not_before formats: - UNIX + - ISO8601 - date: if: ctx.tls?.server?.not_after != null field: tls.server.not_after target_field: tls.server.not_after formats: - UNIX + - ISO8601 - geoip: field: destination.ip target_field: destination.geo diff --git a/x-pack/filebeat/module/zeek/stats/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/stats/ingest/pipeline.yml index 04e851e14a90..b86e9d65dba4 100644 --- a/x-pack/filebeat/module/zeek/stats/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/stats/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.stats.ts formats: - UNIX + - ISO8601 - remove: field: zeek.stats.ts - set: diff --git a/x-pack/filebeat/module/zeek/syslog/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/syslog/ingest/pipeline.yml index 5f3432ec4888..4838fad72c52 100644 --- a/x-pack/filebeat/module/zeek/syslog/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/syslog/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.syslog.ts formats: - UNIX + - ISO8601 - remove: field: zeek.syslog.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/traceroute/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/traceroute/ingest/pipeline.yml index f4744c540d71..da5f549f23ef 100644 --- a/x-pack/filebeat/module/zeek/traceroute/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/traceroute/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.traceroute.ts formats: - UNIX + - ISO8601 - remove: field: zeek.traceroute.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/tunnel/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/tunnel/ingest/pipeline.yml index 9ca83da33051..51c912764fbd 100644 --- a/x-pack/filebeat/module/zeek/tunnel/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/tunnel/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.tunnel.ts formats: - UNIX + - ISO8601 - remove: field: zeek.tunnel.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/weird/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/weird/ingest/pipeline.yml index d791eb77a09c..8ee448cda4de 100644 --- a/x-pack/filebeat/module/zeek/weird/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/weird/ingest/pipeline.yml @@ -10,6 +10,7 @@ processors: field: zeek.weird.ts formats: - UNIX + - ISO8601 - remove: field: zeek.weird.ts - geoip: diff --git a/x-pack/filebeat/module/zeek/x509/ingest/pipeline.yml b/x-pack/filebeat/module/zeek/x509/ingest/pipeline.yml index db9317cca6e7..ccca3995ad7b 100644 --- a/x-pack/filebeat/module/zeek/x509/ingest/pipeline.yml +++ b/x-pack/filebeat/module/zeek/x509/ingest/pipeline.yml @@ -11,6 +11,7 @@ processors: field: zeek.x509.ts formats: - UNIX + - ISO8601 - remove: field: zeek.x509.ts - set: @@ -129,6 +130,7 @@ processors: target_field: zeek.x509.certificate.valid.from formats: - UNIX + - ISO8601 if: ctx.zeek.x509.certificate?.valid?.from != null - set: field: file.x509.not_before @@ -139,6 +141,7 @@ processors: target_field: zeek.x509.certificate.valid.until formats: - UNIX + - ISO8601 if: ctx.zeek.x509.certificate?.valid?.until != null - set: field: file.x509.not_after From 472e3a7c037fbcf30ef4c39ae438ba9d9be1ea1e Mon Sep 17 00:00:00 2001 From: Aleksandr Maus Date: Thu, 10 Jun 2021 11:56:44 -0400 Subject: [PATCH 19/26] Populate the agent action result if there is no matching action handlers (#26152) --- .../pipeline/actions/handlers/handler_action_application.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/x-pack/elastic-agent/pkg/agent/application/pipeline/actions/handlers/handler_action_application.go b/x-pack/elastic-agent/pkg/agent/application/pipeline/actions/handlers/handler_action_application.go index a8e7b883258e..5a49fdeb1847 100644 --- a/x-pack/elastic-agent/pkg/agent/application/pipeline/actions/handlers/handler_action_application.go +++ b/x-pack/elastic-agent/pkg/agent/application/pipeline/actions/handlers/handler_action_application.go @@ -41,7 +41,11 @@ func (h *AppAction) Handle(ctx context.Context, a fleetapi.Action, acker store.F appState, ok := h.srv.FindByInputType(action.InputType) if !ok { - return fmt.Errorf("matching app is not found for action input: %s", action.InputType) + // If the matching action is not found ack the action with the error for action result document + action.StartedAt = time.Now().UTC().Format(time.RFC3339Nano) + action.CompletedAt = action.StartedAt + action.Error = fmt.Sprintf("matching app is not found for action input: %s", action.InputType) + return acker.Ack(ctx, action) } params, err := action.MarshalMap() From 30b9c8fbe24737bc62278e4cb895ba7da6d0d4ef Mon Sep 17 00:00:00 2001 From: kaiyan-sheng Date: Fri, 11 Jun 2021 05:30:29 +0800 Subject: [PATCH 20/26] rename sqs file name (#26227) --- x-pack/metricbeat/module/aws/cloudwatch/metadata.go | 6 +++--- .../module/aws/cloudwatch/{ => metadata}/ec2/ec2.go | 0 .../module/aws/cloudwatch/{ => metadata}/rds/rds.go | 0 .../aws/cloudwatch/{sqs/metadata.go => metadata/sqs/sqs.go} | 0 4 files changed, 3 insertions(+), 3 deletions(-) rename x-pack/metricbeat/module/aws/cloudwatch/{ => metadata}/ec2/ec2.go (100%) rename x-pack/metricbeat/module/aws/cloudwatch/{ => metadata}/rds/rds.go (100%) rename x-pack/metricbeat/module/aws/cloudwatch/{sqs/metadata.go => metadata/sqs/sqs.go} (100%) diff --git a/x-pack/metricbeat/module/aws/cloudwatch/metadata.go b/x-pack/metricbeat/module/aws/cloudwatch/metadata.go index 1c9aac5016af..7c0a82aafdf4 100644 --- a/x-pack/metricbeat/module/aws/cloudwatch/metadata.go +++ b/x-pack/metricbeat/module/aws/cloudwatch/metadata.go @@ -8,9 +8,9 @@ import ( awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/elastic/beats/v7/metricbeat/mb" - "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/ec2" - "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/rds" - "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/sqs" + "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/metadata/ec2" + "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/metadata/rds" + "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/metadata/sqs" ) // AWS namespaces diff --git a/x-pack/metricbeat/module/aws/cloudwatch/ec2/ec2.go b/x-pack/metricbeat/module/aws/cloudwatch/metadata/ec2/ec2.go similarity index 100% rename from x-pack/metricbeat/module/aws/cloudwatch/ec2/ec2.go rename to x-pack/metricbeat/module/aws/cloudwatch/metadata/ec2/ec2.go diff --git a/x-pack/metricbeat/module/aws/cloudwatch/rds/rds.go b/x-pack/metricbeat/module/aws/cloudwatch/metadata/rds/rds.go similarity index 100% rename from x-pack/metricbeat/module/aws/cloudwatch/rds/rds.go rename to x-pack/metricbeat/module/aws/cloudwatch/metadata/rds/rds.go diff --git a/x-pack/metricbeat/module/aws/cloudwatch/sqs/metadata.go b/x-pack/metricbeat/module/aws/cloudwatch/metadata/sqs/sqs.go similarity index 100% rename from x-pack/metricbeat/module/aws/cloudwatch/sqs/metadata.go rename to x-pack/metricbeat/module/aws/cloudwatch/metadata/sqs/sqs.go From ad7c19fdcf1cca1071d0514495f13c0085b5d694 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 10 Jun 2021 17:35:43 -0500 Subject: [PATCH 21/26] [Heartbeat] Fix broken invocation of synth package (#26228) Fixes invocation of synthetics broken in #26188 Additionally, for dev purposes, this lets accepts a synthetics version of file:/// as valid to help with debugging development versions of the synthetics agent. Never released, so no changelog needed Still just sticking with unit tests here since testing more deeply with synthetics (esp. master where this is a problem) is a larger problem than we're equipped to handle ATM. --- .../browser/source/validatepackage.go | 5 ++ .../browser/source/validatepackage_test.go | 5 ++ .../monitors/browser/synthexec/synthexec.go | 10 ++-- .../browser/synthexec/synthexec_test.go | 53 +++++++++++++++++++ 4 files changed, 70 insertions(+), 3 deletions(-) diff --git a/x-pack/heartbeat/monitors/browser/source/validatepackage.go b/x-pack/heartbeat/monitors/browser/source/validatepackage.go index 0828dab5aaba..bc606ffe8373 100644 --- a/x-pack/heartbeat/monitors/browser/source/validatepackage.go +++ b/x-pack/heartbeat/monitors/browser/source/validatepackage.go @@ -42,6 +42,10 @@ func parseVersion(version string) string { } func validateVersion(expected string, current string) error { + if strings.HasPrefix(current, "file://") { + return nil + } + expectedRange, err := semver.NewConstraint(expected) if err != nil { return err @@ -75,6 +79,7 @@ func validatePackageJSON(path string) error { if synthVersion == "" { synthVersion = pkgJson.DevDependencies.SynthVersion } + err = validateVersion(ExpectedSynthVersion, synthVersion) if err != nil { return fmt.Errorf("could not validate @elastic/synthetics version: '%s' %w", synthVersion, err) diff --git a/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go b/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go index c084078424b8..014e1fd2fa98 100644 --- a/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go +++ b/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go @@ -70,6 +70,11 @@ func TestValidateVersion(t *testing.T) { current: "0.0.1-alpha.11", shouldErr: false, }, + { + expected: "", + current: "file://blahblahblah", + shouldErr: false, + }, } for _, tt := range tests { diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go b/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go index c26f138ab238..3dc274061dbd 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthexec.go @@ -30,12 +30,12 @@ const debugSelector = "synthexec" func SuiteJob(ctx context.Context, suitePath string, params common.MapStr, extraArgs ...string) (jobs.Job, error) { // Run the command in the given suitePath, use '.' as the first arg since the command runs // in the correct dir - newCmd, err := suiteCommandFactory(suitePath, append(extraArgs, ".")...) + cmdFactory, err := suiteCommandFactory(suitePath, extraArgs...) if err != nil { return nil, err } - return startCmdJob(ctx, newCmd, nil, params), nil + return startCmdJob(ctx, cmdFactory, nil, params), nil } func suiteCommandFactory(suitePath string, args ...string) (func() *exec.Cmd, error) { @@ -46,7 +46,11 @@ func suiteCommandFactory(suitePath string, args ...string) (func() *exec.Cmd, er newCmd := func() *exec.Cmd { bin := filepath.Join(npmRoot, "node_modules/.bin/elastic-synthetics") - cmd := exec.Command(bin, args...) + // Always put the suite path first to prevent conflation with variadic args! + // See https://github.com/tj/commander.js/blob/master/docs/options-taking-varying-arguments.md + // Note, we don't use the -- approach because it's cleaner to always know we can add new options + // to the end. + cmd := exec.Command(bin, append([]string{suitePath}, args...)...) cmd.Dir = npmRoot return cmd } diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go b/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go index 01f7f8649070..730df8a8ec24 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go @@ -157,3 +157,56 @@ Loop: }) } } + +func TestSuiteCommandFactory(t *testing.T) { + _, filename, _, _ := runtime.Caller(0) + origPath := path.Join(filepath.Dir(filename), "../source/fixtures/todos") + suitePath, err := filepath.Abs(origPath) + require.NoError(t, err) + binPath := path.Join(suitePath, "node_modules/.bin/elastic-synthetics") + + tests := []struct { + name string + suitePath string + extraArgs []string + want []string + wantErr bool + }{ + { + "no args", + suitePath, + nil, + []string{binPath, suitePath}, + false, + }, + { + "with args", + suitePath, + []string{"--capability", "foo", "bar", "--rich-events"}, + []string{binPath, suitePath, "--capability", "foo", "bar", "--rich-events"}, + false, + }, + { + "no npm root", + "/not/a/path/for/sure", + nil, + nil, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + factory, err := suiteCommandFactory(tt.suitePath, tt.extraArgs...) + + if tt.wantErr { + require.Error(t, err) + return + } + require.NoError(t, err) + + cmd := factory() + got := cmd.Args + require.Equal(t, tt.want, got) + }) + } +} From bfbadaa59553a27549eec851beaefe2c7df5c397 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20=C3=81lvarez?= Date: Fri, 11 Jun 2021 22:45:34 +0200 Subject: [PATCH 22/26] Add more ECS fields to logs (#25998) --- libbeat/logp/config.go | 11 +++++++++++ libbeat/logp/core.go | 13 ++++++++----- libbeat/logp/core_test.go | 27 +++++++++++++++++++++++++++ 3 files changed, 46 insertions(+), 5 deletions(-) diff --git a/libbeat/logp/config.go b/libbeat/logp/config.go index d6495cb985a4..19957e2bdc50 100644 --- a/libbeat/logp/config.go +++ b/libbeat/logp/config.go @@ -80,3 +80,14 @@ func DefaultConfig(environment Environment) Config { addCaller: true, } } + +// LogFilename returns the base filename to which logs will be written for +// the "files" log output. If another log output is used, or `logging.files.name` +// is unspecified, then the beat name will be returned. +func (cfg Config) LogFilename() string { + name := cfg.Beat + if cfg.Files.Name != "" { + name = cfg.Files.Name + } + return name +} diff --git a/libbeat/logp/core.go b/libbeat/logp/core.go index f4ccb2eece2e..0bcf76f5edce 100644 --- a/libbeat/logp/core.go +++ b/libbeat/logp/core.go @@ -196,6 +196,13 @@ func makeOptions(cfg Config) []zap.Option { if cfg.development { options = append(options, zap.Development()) } + if cfg.ECSEnabled { + fields := []zap.Field{ + zap.String("service.name", cfg.Beat), + zap.String("event.dataset", cfg.LogFilename()), + } + options = append(options, zap.Fields(fields...)) + } return options } @@ -226,11 +233,7 @@ func makeEventLogOutput(cfg Config) (zapcore.Core, error) { } func makeFileOutput(cfg Config) (zapcore.Core, error) { - name := cfg.Beat - if cfg.Files.Name != "" { - name = cfg.Files.Name - } - filename := paths.Resolve(paths.Logs, filepath.Join(cfg.Files.Path, name)) + filename := paths.Resolve(paths.Logs, filepath.Join(cfg.Files.Path, cfg.LogFilename())) rotator, err := file.NewFileRotator(filename, file.MaxSizeBytes(cfg.Files.MaxSize), diff --git a/libbeat/logp/core_test.go b/libbeat/logp/core_test.go index 9ebe0bb38de4..760bfe13918a 100644 --- a/libbeat/logp/core_test.go +++ b/libbeat/logp/core_test.go @@ -146,3 +146,30 @@ func TestNotDebugAllStdoutDisablesDefaultGoLogger(t *testing.T) { DevelopmentSetup(WithSelectors("other"), WithLevel(InfoLevel)) assert.Equal(t, ioutil.Discard, golog.Writer()) } + +func TestLoggingECSFields(t *testing.T) { + cfg := Config{ + Beat: "beat1", + Level: DebugLevel, + development: true, + ECSEnabled: true, + Files: FileConfig{ + Name: "beat1.log", + }, + } + ToObserverOutput()(&cfg) + Configure(cfg) + + logger := NewLogger("tester") + + logger.Debug("debug") + logs := ObserverLogs().TakeAll() + if assert.Len(t, logs, 1) { + if assert.Len(t, logs[0].Context, 2) { + assert.Equal(t, "service.name", logs[0].Context[0].Key) + assert.Equal(t, "beat1", logs[0].Context[0].String) + assert.Equal(t, "event.dataset", logs[0].Context[1].Key) + assert.Equal(t, "beat1.log", logs[0].Context[1].String) + } + } +} From 81e5cc05c9d449c07de4fa2e4b4df8f36dda46cb Mon Sep 17 00:00:00 2001 From: Marius Iversen Date: Mon, 14 Jun 2021 14:21:22 +0200 Subject: [PATCH 23/26] [Oracle] Fixing default values for paths in config template (#26276) * fixing some typos in the default oracle config, and adding default values * adding changelog entry --- CHANGELOG.next.asciidoc | 1 + x-pack/filebeat/filebeat.reference.yml | 2 +- x-pack/filebeat/module/oracle/_meta/config.yml | 2 +- x-pack/filebeat/module/oracle/database_audit/manifest.yml | 5 ++++- x-pack/filebeat/modules.d/oracle.yml.disabled | 2 +- 5 files changed, 8 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 6be32d56ea13..554914641337 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -280,6 +280,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix integer overflow in S3 offsets when collecting very large files. {pull}22523[22523] - Fix CredentialsJSON unpacking for `gcp-pubsub` and `httpjson` inputs. {pull}23277[23277] - Fix issue with m365_defender, when parsing incidents that has no alerts attached: {pull}25421[25421] +- Fix default config template values for paths on oracle module: {pull}26276[26276] *Filebeat* diff --git a/x-pack/filebeat/filebeat.reference.yml b/x-pack/filebeat/filebeat.reference.yml index f712a3f7e0e5..b1b049121123 100644 --- a/x-pack/filebeat/filebeat.reference.yml +++ b/x-pack/filebeat/filebeat.reference.yml @@ -1759,7 +1759,7 @@ filebeat.modules: # Set paths for the log files when file input is used. # Should only be used together with file input - # var.paths: /home/user/oracleauditlogs/*.aud + #var.paths: ["/home/user/oracleauditlogs/*.aud"] #------------------------------- Osquery Module ------------------------------- - module: osquery diff --git a/x-pack/filebeat/module/oracle/_meta/config.yml b/x-pack/filebeat/module/oracle/_meta/config.yml index 89485db77f67..7b1f569b835c 100644 --- a/x-pack/filebeat/module/oracle/_meta/config.yml +++ b/x-pack/filebeat/module/oracle/_meta/config.yml @@ -7,4 +7,4 @@ # Set paths for the log files when file input is used. # Should only be used together with file input - # var.paths: /home/user/oracleauditlogs/*.aud + #var.paths: ["/home/user/oracleauditlogs/*.aud"] diff --git a/x-pack/filebeat/module/oracle/database_audit/manifest.yml b/x-pack/filebeat/module/oracle/database_audit/manifest.yml index 6e2a4e1e7d9a..f297355c48cd 100644 --- a/x-pack/filebeat/module/oracle/database_audit/manifest.yml +++ b/x-pack/filebeat/module/oracle/database_audit/manifest.yml @@ -1,6 +1,9 @@ module_version: 1.0 var: + - name: paths + default: + - /home/user/oracleauditlogs/*.aud - name: tags default: [oracle-database-audit] - name: input @@ -8,4 +11,4 @@ var: ingest_pipeline: - ingest/pipeline.yml -input: config/config.yml +input: config/config.yml \ No newline at end of file diff --git a/x-pack/filebeat/modules.d/oracle.yml.disabled b/x-pack/filebeat/modules.d/oracle.yml.disabled index 0a7819e55dec..d8b1d8c58e2d 100644 --- a/x-pack/filebeat/modules.d/oracle.yml.disabled +++ b/x-pack/filebeat/modules.d/oracle.yml.disabled @@ -10,4 +10,4 @@ # Set paths for the log files when file input is used. # Should only be used together with file input - # var.paths: /home/user/oracleauditlogs/*.aud + #var.paths: ["/home/user/oracleauditlogs/*.aud"] From 2ebf83ee39989f4a2c87ed859501241a4c777a54 Mon Sep 17 00:00:00 2001 From: Andrew Kroh Date: Mon, 14 Jun 2021 08:28:33 -0400 Subject: [PATCH 24/26] Change xml processor names in script processor to match convention (#26263) In the script processor, the `decode_xml` and `decode_xml_wineventlog` processors are now available as `DecodeXML` and `DecodeXMLWineventlog` respectively. This follows the same naming conventions as other processors exposed though the `script` processor. For example you can write `new processor.DecodeXML({...})`. --- CHANGELOG.next.asciidoc | 1 + libbeat/processors/decode_xml/decode_xml.go | 2 +- libbeat/processors/decode_xml_wineventlog/processor.go | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 554914641337..240ca7d4cc6a 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -242,6 +242,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix handling of `file_selectors` in aws-s3 input. {pull}25792[25792] - Fix ILM alias creation when write alias exists and initial index does not exist {pull}26143[26143] - Include date separator in the filename prefix of `dateRotator` to make sure nothing gets purged accidentally {pull}26176[26176] +- In the script processor, the `decode_xml` and `decode_xml_wineventlog` processors are now available as `DecodeXML` and `DecodeXMLWineventlog` respectively. *Auditbeat* diff --git a/libbeat/processors/decode_xml/decode_xml.go b/libbeat/processors/decode_xml/decode_xml.go index ced399c00fad..ae90e1b29900 100644 --- a/libbeat/processors/decode_xml/decode_xml.go +++ b/libbeat/processors/decode_xml/decode_xml.go @@ -59,7 +59,7 @@ func init() { "to_lower", "ignore_missing", "ignore_failure", ))) - jsprocessor.RegisterPlugin(procName, New) + jsprocessor.RegisterPlugin("DecodeXML", New) } // New constructs a new decode_xml processor. diff --git a/libbeat/processors/decode_xml_wineventlog/processor.go b/libbeat/processors/decode_xml_wineventlog/processor.go index a64c678dfe82..c73ea5ff521c 100644 --- a/libbeat/processors/decode_xml_wineventlog/processor.go +++ b/libbeat/processors/decode_xml_wineventlog/processor.go @@ -51,7 +51,7 @@ func init() { "overwrite_keys", "map_ecs_fields", "ignore_missing", "ignore_failure", ))) - jsprocessor.RegisterPlugin(procName, New) + jsprocessor.RegisterPlugin("DecodeXMLWineventlog", New) } type processor struct { From 08eaadbdf52caabde11cab493863992388a128e5 Mon Sep 17 00:00:00 2001 From: Marc Guasch Date: Mon, 14 Jun 2021 16:34:30 +0200 Subject: [PATCH 25/26] [filebeat] Add preserve_original_event option to o365audit input (#26273) * Add preserve_original_event option to o365audit input * Use String method from MapStr * Add test --- CHANGELOG.next.asciidoc | 1 + .../docs/inputs/input-o365audit.asciidoc | 5 +++ x-pack/filebeat/input/o365audit/config.go | 4 ++ x-pack/filebeat/input/o365audit/input.go | 3 ++ x-pack/filebeat/input/o365audit/input_test.go | 38 +++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 x-pack/filebeat/input/o365audit/input_test.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 240ca7d4cc6a..eb4cb84c76ed 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -823,6 +823,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Make `filestream` input GA. {pull}26127[26127] - Add new `parser` to `filestream` input: `container`. {pull}26115[26115] - Add support for ISO8601 timestamps in Zeek fileset {pull}25564[25564] +- Add `preserve_original_event` option to `o365audit` input. {pull}26273[26273] *Heartbeat* diff --git a/x-pack/filebeat/docs/inputs/input-o365audit.asciidoc b/x-pack/filebeat/docs/inputs/input-o365audit.asciidoc index 080bd8aa657b..62ec3880c256 100644 --- a/x-pack/filebeat/docs/inputs/input-o365audit.asciidoc +++ b/x-pack/filebeat/docs/inputs/input-o365audit.asciidoc @@ -133,6 +133,11 @@ default is `2000`, as this is the server-side limit per tenant. The maximum time window that API allows in a single query. Defaults to `24h` to match Microsoft's documented limit. +===== `api.preserve_original_event` + +Controls whether the original o365 audit object will be kept in `event.original` + or not. Defaults to `false`. + [id="{beatname_lc}-input-{type}-common-options"] include::../../../../filebeat/docs/inputs/input-common-options.asciidoc[] diff --git a/x-pack/filebeat/input/o365audit/config.go b/x-pack/filebeat/input/o365audit/config.go index cb703e61bd19..97402971e38d 100644 --- a/x-pack/filebeat/input/o365audit/config.go +++ b/x-pack/filebeat/input/o365audit/config.go @@ -83,6 +83,10 @@ type APIConfig struct { // duplicates. SetIDFromAuditRecord bool `config:"set_id_from_audit_record"` + // PreserveOriginalEvent controls whether the original o365 audit object + // will be kept in `event.original` or not. + PreserveOriginalEvent bool `config:"preserve_original_event"` + // MaxQuerySize is the maximum time window that can be queried. The default // is 24h. MaxQuerySize time.Duration `config:"max_query_size" validate:"positive"` diff --git a/x-pack/filebeat/input/o365audit/input.go b/x-pack/filebeat/input/o365audit/input.go index 2cf76de9ee30..5be035fd489e 100644 --- a/x-pack/filebeat/input/o365audit/input.go +++ b/x-pack/filebeat/input/o365audit/input.go @@ -253,6 +253,9 @@ func (env apiEnvironment) toBeatEvent(doc common.MapStr) beat.Event { b.SetID(id) } } + if env.Config.PreserveOriginalEvent { + b.PutValue("event.original", doc.String()) + } if len(errs) > 0 { msgs := make([]string, len(errs)) for idx, e := range errs { diff --git a/x-pack/filebeat/input/o365audit/input_test.go b/x-pack/filebeat/input/o365audit/input_test.go new file mode 100644 index 000000000000..a84c58544dda --- /dev/null +++ b/x-pack/filebeat/input/o365audit/input_test.go @@ -0,0 +1,38 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package o365audit + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/elastic/beats/v7/libbeat/common" +) + +func TestPreserveOriginalEvent(t *testing.T) { + env := apiEnvironment{ + Config: APIConfig{PreserveOriginalEvent: false}, + } + + doc := common.MapStr{ + "field1": "val1", + } + + event := env.toBeatEvent(doc) + + v, err := event.GetValue("event.original") + require.EqualError(t, err, "key not found") + assert.Nil(t, v) + + env.Config.PreserveOriginalEvent = true + + event = env.toBeatEvent(doc) + + v, err = event.GetValue("event.original") + require.NoError(t, err) + assert.JSONEq(t, `{"field1":"val1"}`, v.(string)) +} From 6c0f28bd055c4c886c564b4174dc00f64ff0c3b9 Mon Sep 17 00:00:00 2001 From: Jaime Soriano Pastor Date: Mon, 14 Jun 2021 17:33:21 +0200 Subject: [PATCH 26/26] Report total and free CPU for vSphere virtual machines (#26167) Use configured CPU as total, use it to calculate free too. Total and free resources are only reported if they are configured with a total greater than zero. --- CHANGELOG.next.asciidoc | 1 + metricbeat/docs/fields.asciidoc | 20 ++++++++++ metricbeat/module/vsphere/fields.go | 2 +- .../vsphere/virtualmachine/_meta/data.json | 25 +++++++----- .../vsphere/virtualmachine/_meta/fields.yml | 8 ++++ .../vsphere/virtualmachine/virtualmachine.go | 40 ++++++++++++------- .../virtualmachine/virtualmachine_test.go | 6 +-- 7 files changed, 75 insertions(+), 27 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index eb4cb84c76ed..484ad4bf74e5 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -958,6 +958,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Reduce number of requests done by kubernetes metricsets to kubelet. {pull}25782[25782] - Migrate rds metricsets to use cloudwatch input. {pull}26077[26077] - Migrate sqs metricsets to use cloudwatch input. {pull}26117[26117] +- Add total CPU to vSphere virtual machine metrics. {pull}26167[26167] *Packetbeat* diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 710ef15ec459..5ce8bad7f2c5 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -53624,6 +53624,26 @@ type: keyword Used CPU in Mhz +type: long + +-- + +*`vsphere.virtualmachine.cpu.total.mhz`*:: ++ +-- +Total CPU in Mhz + + +type: long + +-- + +*`vsphere.virtualmachine.cpu.free.mhz`*:: ++ +-- +Available CPU in Mhz + + type: long -- diff --git a/metricbeat/module/vsphere/fields.go b/metricbeat/module/vsphere/fields.go index 97a810ae68c9..99cf119cd813 100644 --- a/metricbeat/module/vsphere/fields.go +++ b/metricbeat/module/vsphere/fields.go @@ -32,5 +32,5 @@ func init() { // AssetVsphere returns asset data. // This is the base64 encoded gzipped contents of module/vsphere. func AssetVsphere() string { - return "eJzMlsFymzAQhu9+ip3c4wfg0Es6aS9uO5OmV48Ci61asIy0JEOfviMJPCDkximijQ6eMRL//4HYf3ULJ+wyeDbNETVuAFiywgxunh/clZsNQIEm17JhSXUGHzYAAP0sVFS0yt6mUaEwmMFBbABKiaowmVt6C7WocGxhB3eNXaypbforEZep0FisECwM01kuLnlRtp+KiEyfYxghxhjF/k4mBpITdi+ki2DuDzx2fByY5rqDYWmsfjrLe6nQdIaxgpnw4JmLRuSSuy0TC7V96hhNlEBRfXib/XerCE4RqAQ+YnRj7ChJV4IzmNvPOEuNmBTzXiMmp2wNFkkpHw0W61A2OUcZTS4UFvtSkQgXXMPaoM6x5mtp++Xn2VkwHMnwkkwI7v/fcfCZDF9Ogrxp/eZUx18pP6C7b48ga9gFqmNbnwPpfH0KXGHsCjudryvrV2wrrEivVaw7J27tY9KvV2kPt1YuJ8JbJ46XwtXIL6RPe/svDvZXRfvFy8JU9nwOkppboSqRH2W96PxyUentqWVjbyvD51waXIHgxMz+rJSVQzMJsnytjP7htwF2fh8uxzUl/MZC068NasGyPsCDP8q9t6YxDtFDi4ZXi1Iq4ZM1WBxajtV9rCui+kJJkv7pX+ukByR7r64ZpIcdt4TlrHlrmKq9D80oIT39xNmh2F/cL6jsO2cMEeN/2rZ+BwAA//8rvBJ+" + return "eJzsl8+OmzAQxu95itHedx+AQ6Vqq20vaSttt9fIgSG4MQyyh6zo01e2IeKP002KaS/1ASnYfN8PzHxD7uGIbQInUxeocQPAkhUmcHd6dmfuNgAZmlTLmiVVCbzbAAB0s1BS1ih7mUaFwmACB7EByCWqzCRu6T1UosShhR3c1naxpqbuzgRcxkJDsUywMExnubDkRdluKiAyvo9+TDGGKPY4muhJjti+ks4mc7/hseNDzzTX7Q1zY/XjWT5JhaY1jCXMhHvPVNQildw+MLFQD/uW0QQJFFWH2+y/WUVwikA5cIHBjbEjJ10KTmBuP+PMNWJUzCeNGJ2yMZhFpXwxmK1DWaccZDSpUJjtckViuuAa1hp1ihVfS9stP8/OgqEgw0syYXL9v46DT2T4chKkdeM3pyx+xnyBHr++gKxgO1Ed2vociOfrU+AKY1fY8XxdWb9hW2JJeq1i3Tpxax+SfrtKO7i1cjkS3jpxvBSuQn4lfdzZX2GwPyraz14WxrLn7yCpuRGqFGkhq0XfLxeVbk8tG3sPcnqfS4NrIjgys4eVsrJvJpMsXyujv/ttgK3fh8txTRHfsanplxq1YFkd4Nl/yv1vGus1jfcnIZXYq5s6x6FBw6v1D8rhozVYnNSO1VXoiqg+HaK0vPiPddT4oj1X9wrGhx32weWsaWOYyp3vFEFC2v/A2T8Bf3K3IM4enTEEjP9qr/4VAAD//9YITTs=" } diff --git a/metricbeat/module/vsphere/virtualmachine/_meta/data.json b/metricbeat/module/vsphere/virtualmachine/_meta/data.json index cae229ceaebe..4dfa302758ce 100644 --- a/metricbeat/module/vsphere/virtualmachine/_meta/data.json +++ b/metricbeat/module/vsphere/virtualmachine/_meta/data.json @@ -1,14 +1,17 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", - "beat": { - "hostname": "host.example.com", - "name": "host.example.com" + "event": { + "dataset": "vsphere.virtualmachine", + "duration": 115000, + "module": "vsphere" }, "metricset": { - "host": "http://127.0.0.1:35887/sdk", - "module": "vsphere", "name": "virtualmachine", - "rtt": 115 + "period": 10000 + }, + "service": { + "address": "http://127.0.0.1:37231/sdk", + "type": "vsphere" }, "vsphere": { "virtualmachine": { @@ -17,8 +20,8 @@ "mhz": 0 } }, - "host.id": "ha-host", "host.hostname": "localhost.localdomain", + "host.id": "ha-host", "memory": { "free": { "guest": { @@ -39,7 +42,11 @@ } } }, - "name": "ha-host_VM1" + "name": "ha-host_VM0", + "network_names": [ + "VM Network" + ], + "os": "otherGuest" } } -} +} \ No newline at end of file diff --git a/metricbeat/module/vsphere/virtualmachine/_meta/fields.yml b/metricbeat/module/vsphere/virtualmachine/_meta/fields.yml index fbbbeec5691f..723d611b2e1a 100644 --- a/metricbeat/module/vsphere/virtualmachine/_meta/fields.yml +++ b/metricbeat/module/vsphere/virtualmachine/_meta/fields.yml @@ -24,6 +24,14 @@ type: long description: > Used CPU in Mhz + - name: cpu.total.mhz + type: long + description: > + Total CPU in Mhz + - name: cpu.free.mhz + type: long + description: > + Available CPU in Mhz - name: memory.used.guest.bytes type: long description: > diff --git a/metricbeat/module/vsphere/virtualmachine/virtualmachine.go b/metricbeat/module/vsphere/virtualmachine/virtualmachine.go index 1179b36b5b8c..938bf91c97ba 100644 --- a/metricbeat/module/vsphere/virtualmachine/virtualmachine.go +++ b/metricbeat/module/vsphere/virtualmachine/virtualmachine.go @@ -132,38 +132,50 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error { } for _, vm := range vmt { - freeMemory := (int64(vm.Summary.Config.MemorySizeMB) * 1024 * 1024) - (int64(vm.Summary.QuickStats.GuestMemoryUsage) * 1024 * 1024) - + usedMemory := int64(vm.Summary.QuickStats.GuestMemoryUsage) * 1024 * 1024 + usedCPU := vm.Summary.QuickStats.OverallCpuUsage event := common.MapStr{ "name": vm.Summary.Config.Name, "os": vm.Summary.Config.GuestFullName, "cpu": common.MapStr{ "used": common.MapStr{ - "mhz": vm.Summary.QuickStats.OverallCpuUsage, + "mhz": usedCPU, }, }, "memory": common.MapStr{ "used": common.MapStr{ "guest": common.MapStr{ - "bytes": (int64(vm.Summary.QuickStats.GuestMemoryUsage) * 1024 * 1024), + "bytes": usedMemory, }, "host": common.MapStr{ "bytes": int64(vm.Summary.QuickStats.HostMemoryUsage) * 1024 * 1024, }, }, - "total": common.MapStr{ - "guest": common.MapStr{ - "bytes": int64(vm.Summary.Config.MemorySizeMB) * 1024 * 1024, - }, - }, - "free": common.MapStr{ - "guest": common.MapStr{ - "bytes": freeMemory, - }, - }, }, } + totalCPU := vm.Summary.Config.CpuReservation + if totalCPU > 0 { + freeCPU := totalCPU - usedCPU + // Avoid negative values if reported used CPU is slightly over total configured. + if freeCPU < 0 { + freeCPU = 0 + } + event.Put("cpu.total.mhz", totalCPU) + event.Put("cpu.free.mhz", freeCPU) + } + + totalMemory := int64(vm.Summary.Config.MemorySizeMB) * 1024 * 1024 + if totalMemory > 0 { + freeMemory := totalMemory - usedMemory + // Avoid negative values if reported used memory is slightly over total configured. + if freeMemory < 0 { + freeMemory = 0 + } + event.Put("memory.total.guest.bytes", totalMemory) + event.Put("memory.free.guest.bytes", freeMemory) + } + if host := vm.Summary.Runtime.Host; host != nil { event["host.id"] = host.Value hostSystem, err := getHostSystem(ctx, c, host.Reference()) diff --git a/metricbeat/module/vsphere/virtualmachine/virtualmachine_test.go b/metricbeat/module/vsphere/virtualmachine/virtualmachine_test.go index e3b12feaf4b7..83a2db898dd7 100644 --- a/metricbeat/module/vsphere/virtualmachine/virtualmachine_test.go +++ b/metricbeat/module/vsphere/virtualmachine/virtualmachine_test.go @@ -21,11 +21,11 @@ import ( "strings" "testing" - "github.com/elastic/beats/v7/libbeat/common" - mbtest "github.com/elastic/beats/v7/metricbeat/mb/testing" - "github.com/stretchr/testify/assert" "github.com/vmware/govmomi/simulator" + + "github.com/elastic/beats/v7/libbeat/common" + mbtest "github.com/elastic/beats/v7/metricbeat/mb/testing" ) func TestFetchEventContents(t *testing.T) {