From ccc2ac93c577adabc4c4feff7c3e0965344f8cbd Mon Sep 17 00:00:00 2001 From: apmmachine <58790750+apmmachine@users.noreply.github.com> Date: Thu, 17 Jun 2021 11:51:32 -0400 Subject: [PATCH 01/20] [Automation] Update elastic stack version to 8.0.0-943ef2c0 for testing (#26354) Co-authored-by: apmmachine --- testing/environments/snapshot-oss.yml | 6 +++--- testing/environments/snapshot.yml | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/testing/environments/snapshot-oss.yml b/testing/environments/snapshot-oss.yml index 4a8bcda13e2..104eed8ee4f 100644 --- a/testing/environments/snapshot-oss.yml +++ b/testing/environments/snapshot-oss.yml @@ -3,7 +3,7 @@ version: '2.3' services: elasticsearch: - image: docker.elastic.co/elasticsearch/elasticsearch:8.0.0-SNAPSHOT + image: docker.elastic.co/elasticsearch/elasticsearch:8.0.0-943ef2c0-SNAPSHOT healthcheck: test: ["CMD-SHELL", "curl -s http://localhost:9200/_cat/health?h=status | grep -q green"] retries: 300 @@ -21,7 +21,7 @@ services: - "script.context.template.cache_max_size=2000" logstash: - image: docker.elastic.co/logstash/logstash-oss:8.0.0-SNAPSHOT + image: docker.elastic.co/logstash/logstash-oss:8.0.0-943ef2c0-SNAPSHOT healthcheck: test: ["CMD", "curl", "-f", "http://localhost:9600/_node/stats"] retries: 600 @@ -31,7 +31,7 @@ services: - ./docker/logstash/pki:/etc/pki:ro kibana: - image: docker.elastic.co/kibana/kibana:8.0.0-SNAPSHOT + image: docker.elastic.co/kibana/kibana:8.0.0-943ef2c0-SNAPSHOT healthcheck: test: ["CMD-SHELL", "curl -s http://localhost:5601/api/status | grep -q 'Looking good'"] retries: 600 diff --git a/testing/environments/snapshot.yml b/testing/environments/snapshot.yml index 621af6cc28f..329ec9e1559 100644 --- a/testing/environments/snapshot.yml +++ b/testing/environments/snapshot.yml @@ -3,7 +3,7 @@ version: '2.3' services: elasticsearch: - image: docker.elastic.co/elasticsearch/elasticsearch:8.0.0-SNAPSHOT + image: docker.elastic.co/elasticsearch/elasticsearch:8.0.0-943ef2c0-SNAPSHOT healthcheck: test: ["CMD-SHELL", "curl -s http://localhost:9200/_cat/health?h=status | grep -q green"] retries: 300 @@ -34,7 +34,7 @@ services: - ./docker/logstash/pki:/etc/pki:ro kibana: - image: docker.elastic.co/kibana/kibana:8.0.0-SNAPSHOT + image: docker.elastic.co/kibana/kibana:8.0.0-943ef2c0-SNAPSHOT healthcheck: test: ["CMD-SHELL", "curl -s http://localhost:5601/api/status | grep -q 'Looking good'"] retries: 600 From 69d8ae7bb3f7ec34a6f6d8b7a82f0d9bc1b86bd8 Mon Sep 17 00:00:00 2001 From: Michal Pristas Date: Fri, 18 Jun 2021 08:08:05 +0200 Subject: [PATCH 02/20] Enable agent to send custom headers to kibana/ES (#26275) Enable agent to send custom headers to kibana/ES (#26275) --- x-pack/elastic-agent/CHANGELOG.next.asciidoc | 1 + .../pkg/agent/application/info/agent_id.go | 1 + .../pkg/agent/application/info/agent_info.go | 7 + .../elastic-agent/pkg/agent/cmd/container.go | 142 ++++-------------- x-pack/elastic-agent/pkg/agent/cmd/enroll.go | 24 +++ .../elastic-agent/pkg/agent/cmd/enroll_cmd.go | 31 +++- .../pkg/agent/cmd/setup_config.go | 119 +++++++++++++++ .../pkg/agent/configuration/fleet_server.go | 1 + .../pkg/agent/program/program_test.go | 6 + .../pkg/agent/program/supported.go | 2 +- .../pkg/agent/transpiler/rules.go | 69 +++++++++ .../pkg/agent/transpiler/rules_test.go | 68 +++++++++ x-pack/elastic-agent/spec/apm-server.yml | 1 + x-pack/elastic-agent/spec/filebeat.yml | 3 + x-pack/elastic-agent/spec/fleet-server.yml | 2 + x-pack/elastic-agent/spec/metricbeat.yml | 1 + 16 files changed, 361 insertions(+), 117 deletions(-) create mode 100644 x-pack/elastic-agent/pkg/agent/cmd/setup_config.go diff --git a/x-pack/elastic-agent/CHANGELOG.next.asciidoc b/x-pack/elastic-agent/CHANGELOG.next.asciidoc index 584b2a8985a..fd1556ca0ce 100644 --- a/x-pack/elastic-agent/CHANGELOG.next.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.next.asciidoc @@ -111,3 +111,4 @@ - Keep http and logging config during enroll {pull}25132[25132] - Log output of container to $LOGS_PATH/elastic-agent-start.log when LOGS_PATH set {pull}25150[25150] - Use `filestream` input for internal log collection. {pull}25660[25660] +- Enable agent to send custom headers to kibana/ES {pull}26275[26275] diff --git a/x-pack/elastic-agent/pkg/agent/application/info/agent_id.go b/x-pack/elastic-agent/pkg/agent/application/info/agent_id.go index 386beabca61..6b62f32d396 100644 --- a/x-pack/elastic-agent/pkg/agent/application/info/agent_id.go +++ b/x-pack/elastic-agent/pkg/agent/application/info/agent_id.go @@ -29,6 +29,7 @@ const maxRetriesloadAgentInfo = 5 type persistentAgentInfo struct { ID string `json:"id" yaml:"id" config:"id"` + Headers map[string]string `json:"headers" yaml:"headers" config:"headers"` LogLevel string `json:"logging.level,omitempty" yaml:"logging.level,omitempty" config:"logging.level,omitempty"` MonitoringHTTP *monitoringConfig.MonitoringHTTPConfig `json:"monitoring.http,omitempty" yaml:"monitoring.http,omitempty" config:"monitoring.http,omitempty"` } diff --git a/x-pack/elastic-agent/pkg/agent/application/info/agent_info.go b/x-pack/elastic-agent/pkg/agent/application/info/agent_info.go index 8ae09c2efc3..8ae562919f3 100644 --- a/x-pack/elastic-agent/pkg/agent/application/info/agent_info.go +++ b/x-pack/elastic-agent/pkg/agent/application/info/agent_info.go @@ -13,6 +13,7 @@ import ( type AgentInfo struct { agentID string logLevel string + headers map[string]string } // NewAgentInfoWithLog creates a new agent information. @@ -30,6 +31,7 @@ func NewAgentInfoWithLog(level string, createAgentID bool) (*AgentInfo, error) { return &AgentInfo{ agentID: agentInfo.ID, logLevel: agentInfo.LogLevel, + headers: agentInfo.Headers, }, nil } @@ -84,3 +86,8 @@ func (*AgentInfo) Version() string { func (*AgentInfo) Snapshot() bool { return release.Snapshot() } + +// Headers returns custom headers used to communicate with elasticsearch. +func (i *AgentInfo) Headers() map[string]string { + return i.headers +} diff --git a/x-pack/elastic-agent/pkg/agent/cmd/container.go b/x-pack/elastic-agent/pkg/agent/cmd/container.go index 8f6f8b43fb0..26a14b87fd8 100644 --- a/x-pack/elastic-agent/pkg/agent/cmd/container.go +++ b/x-pack/elastic-agent/pkg/agent/cmd/container.go @@ -271,7 +271,7 @@ func runContainerCmd(streams *cli.IOStreams, cmd *cobra.Command, cfg setupConfig } if cfg.Kibana.Fleet.Setup { - client, err = kibanaClient(cfg.Kibana) + client, err = kibanaClient(cfg.Kibana, cfg.Kibana.Headers) if err != nil { return err } @@ -286,7 +286,7 @@ func runContainerCmd(streams *cli.IOStreams, cmd *cobra.Command, cfg setupConfig token := cfg.Fleet.EnrollmentToken if token == "" && !cfg.FleetServer.Enable { if client == nil { - client, err = kibanaClient(cfg.Kibana) + client, err = kibanaClient(cfg.Kibana, cfg.Kibana.Headers) if err != nil { return err } @@ -363,6 +363,11 @@ func buildEnrollArgs(cfg setupConfig, token string, policyID string) ([]string, if cfg.FleetServer.CertKey != "" { args = append(args, "--fleet-server-cert-key", cfg.FleetServer.CertKey) } + + for k, v := range cfg.FleetServer.Headers { + args = append(args, "--header", k+"="+v) + } + if cfg.Fleet.URL != "" { args = append(args, "--url", cfg.Fleet.URL) } @@ -444,19 +449,21 @@ func kibanaFetchToken(cfg setupConfig, client *kibana.Client, policy *kibanaPoli return keyDetail.Item.APIKey, nil } -func kibanaClient(cfg kibanaConfig) (*kibana.Client, error) { +func kibanaClient(cfg kibanaConfig, headers map[string]string) (*kibana.Client, error) { var tls *tlscommon.Config if cfg.Fleet.CA != "" { tls = &tlscommon.Config{ CAs: []string{cfg.Fleet.CA}, } } + return kibana.NewClientWithConfig(&kibana.ClientConfig{ Host: cfg.Fleet.Host, Username: cfg.Fleet.Username, Password: cfg.Fleet.Password, IgnoreVersion: true, TLS: tls, + Headers: headers, }) } @@ -518,6 +525,27 @@ func envBool(keys ...string) bool { return false } +func envMap(key string) map[string]string { + m := make(map[string]string) + prefix := key + "=" + for _, env := range os.Environ() { + if !strings.HasPrefix(env, prefix) { + continue + } + + envVal := strings.TrimPrefix(env, prefix) + + keyValue := strings.SplitN(envVal, "=", 2) + if len(keyValue) != 2 { + continue + } + + m[keyValue[0]] = keyValue[1] + } + + return m +} + func isTrue(val string) bool { trueVals := []string{"1", "true", "yes", "y"} val = strings.ToLower(val) @@ -815,114 +843,6 @@ type kibanaAPIKeyDetail struct { Item kibanaAPIKey `json:"item"` } -// setup configuration - -type setupConfig struct { - Fleet fleetConfig `config:"fleet"` - FleetServer fleetServerConfig `config:"fleet_server"` - Kibana kibanaConfig `config:"kibana"` -} - -type elasticsearchConfig struct { - CA string `config:"ca"` - Host string `config:"host"` - Username string `config:"username"` - Password string `config:"password"` - ServiceToken string `config:"service_token"` -} - -type fleetConfig struct { - CA string `config:"ca"` - Enroll bool `config:"enroll"` - EnrollmentToken string `config:"enrollment_token"` - Force bool `config:"force"` - Insecure bool `config:"insecure"` - TokenName string `config:"token_name"` - TokenPolicyName string `config:"token_policy_name"` - URL string `config:"url"` -} - -type fleetServerConfig struct { - Cert string `config:"cert"` - CertKey string `config:"cert_key"` - Elasticsearch elasticsearchConfig `config:"elasticsearch"` - Enable bool `config:"enable"` - Host string `config:"host"` - InsecureHTTP bool `config:"insecure_http"` - PolicyID string `config:"policy_id"` - Port string `config:"port"` -} - -type kibanaConfig struct { - Fleet kibanaFleetConfig `config:"fleet"` - RetrySleepDuration time.Duration `config:"retry_sleep_duration"` - RetryMaxCount int `config:"retry_max_count"` -} - -type kibanaFleetConfig struct { - CA string `config:"ca"` - Host string `config:"host"` - Password string `config:"password"` - Setup bool `config:"setup"` - Username string `config:"username"` -} - -func defaultAccessConfig() (setupConfig, error) { - retrySleepDuration, err := envDurationWithDefault(defaultRequestRetrySleep, requestRetrySleepEnv) - if err != nil { - return setupConfig{}, err - } - - retryMaxCount, err := envIntWithDefault(defaultMaxRequestRetries, maxRequestRetriesEnv) - if err != nil { - return setupConfig{}, err - } - - cfg := setupConfig{ - Fleet: fleetConfig{ - CA: envWithDefault("", "FLEET_CA", "KIBANA_CA", "ELASTICSEARCH_CA"), - Enroll: envBool("FLEET_ENROLL", "FLEET_SERVER_ENABLE"), - EnrollmentToken: envWithDefault("", "FLEET_ENROLLMENT_TOKEN"), - Force: envBool("FLEET_FORCE"), - Insecure: envBool("FLEET_INSECURE"), - TokenName: envWithDefault("Default", "FLEET_TOKEN_NAME"), - TokenPolicyName: envWithDefault("", "FLEET_TOKEN_POLICY_NAME"), - URL: envWithDefault("", "FLEET_URL"), - }, - FleetServer: fleetServerConfig{ - Cert: envWithDefault("", "FLEET_SERVER_CERT"), - CertKey: envWithDefault("", "FLEET_SERVER_CERT_KEY"), - Elasticsearch: elasticsearchConfig{ - Host: envWithDefault("http://elasticsearch:9200", "FLEET_SERVER_ELASTICSEARCH_HOST", "ELASTICSEARCH_HOST"), - Username: envWithDefault("elastic", "FLEET_SERVER_ELASTICSEARCH_USERNAME", "ELASTICSEARCH_USERNAME"), - Password: envWithDefault("changeme", "FLEET_SERVER_ELASTICSEARCH_PASSWORD", "ELASTICSEARCH_PASSWORD"), - ServiceToken: envWithDefault("", "FLEET_SERVER_SERVICE_TOKEN"), - CA: envWithDefault("", "FLEET_SERVER_ELASTICSEARCH_CA", "ELASTICSEARCH_CA"), - }, - Enable: envBool("FLEET_SERVER_ENABLE"), - Host: envWithDefault("", "FLEET_SERVER_HOST"), - InsecureHTTP: envBool("FLEET_SERVER_INSECURE_HTTP"), - PolicyID: envWithDefault("", "FLEET_SERVER_POLICY_ID", "FLEET_SERVER_POLICY"), - Port: envWithDefault("", "FLEET_SERVER_PORT"), - }, - Kibana: kibanaConfig{ - Fleet: kibanaFleetConfig{ - // Remove FLEET_SETUP in 8.x - // The FLEET_SETUP environment variable boolean is a fallback to the old name. The name was updated to - // reflect that its setting up Fleet in Kibana versus setting up Fleet Server. - Setup: envBool("KIBANA_FLEET_SETUP", "FLEET_SETUP"), - Host: envWithDefault("http://kibana:5601", "KIBANA_FLEET_HOST", "KIBANA_HOST"), - Username: envWithDefault("elastic", "KIBANA_FLEET_USERNAME", "KIBANA_USERNAME", "ELASTICSEARCH_USERNAME"), - Password: envWithDefault("changeme", "KIBANA_FLEET_PASSWORD", "KIBANA_PASSWORD", "ELASTICSEARCH_PASSWORD"), - CA: envWithDefault("", "KIBANA_FLEET_CA", "KIBANA_CA", "ELASTICSEARCH_CA"), - }, - RetrySleepDuration: retrySleepDuration, - RetryMaxCount: retryMaxCount, - }, - } - return cfg, nil -} - func envDurationWithDefault(defVal string, keys ...string) (time.Duration, error) { valStr := defVal for _, key := range keys { diff --git a/x-pack/elastic-agent/pkg/agent/cmd/enroll.go b/x-pack/elastic-agent/pkg/agent/cmd/enroll.go index 55baf76f56a..2828bc4f0da 100644 --- a/x-pack/elastic-agent/pkg/agent/cmd/enroll.go +++ b/x-pack/elastic-agent/pkg/agent/cmd/enroll.go @@ -10,6 +10,7 @@ import ( "os" "os/signal" "strconv" + "strings" "syscall" "github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/agent/application/paths" @@ -59,6 +60,7 @@ func addEnrollFlags(cmd *cobra.Command) { cmd.Flags().Uint16P("fleet-server-port", "", 0, "Fleet Server HTTP binding port (overrides the policy)") cmd.Flags().StringP("fleet-server-cert", "", "", "Certificate to use for exposed Fleet Server HTTPS endpoint") cmd.Flags().StringP("fleet-server-cert-key", "", "", "Private key to use for exposed Fleet Server HTTPS endpoint") + cmd.Flags().StringSliceP("header", "", []string{}, "Headers used in communication with elasticsearch") cmd.Flags().BoolP("fleet-server-insecure-http", "", false, "Expose Fleet Server over HTTP (not recommended; insecure)") cmd.Flags().StringP("certificate-authorities", "a", "", "Comma separated list of root certificate for server verifications") cmd.Flags().StringP("ca-sha256", "p", "", "Comma separated list of certificate authorities hash pins used for certificate verifications") @@ -81,6 +83,7 @@ func buildEnrollmentFlags(cmd *cobra.Command, url string, token string) []string fPort, _ := cmd.Flags().GetUint16("fleet-server-port") fCert, _ := cmd.Flags().GetString("fleet-server-cert") fCertKey, _ := cmd.Flags().GetString("fleet-server-cert-key") + fHeaders, _ := cmd.Flags().GetStringSlice("header") fInsecure, _ := cmd.Flags().GetBool("fleet-server-insecure-http") ca, _ := cmd.Flags().GetString("certificate-authorities") sha256, _ := cmd.Flags().GetString("ca-sha256") @@ -128,6 +131,12 @@ func buildEnrollmentFlags(cmd *cobra.Command, url string, token string) []string args = append(args, "--fleet-server-cert-key") args = append(args, fCertKey) } + + for k, v := range mapFromEnvList(fHeaders) { + args = append(args, "--header") + args = append(args, k+"="+v) + } + if fInsecure { args = append(args, "--fleet-server-insecure-http") } @@ -211,6 +220,7 @@ func enroll(streams *cli.IOStreams, cmd *cobra.Command, args []string) error { enrollmentToken, _ := cmd.Flags().GetString("enrollment-token") fServer, _ := cmd.Flags().GetString("fleet-server-es") fElasticSearchCA, _ := cmd.Flags().GetString("fleet-server-es-ca") + fHeaders, _ := cmd.Flags().GetStringSlice("header") fServiceToken, _ := cmd.Flags().GetString("fleet-server-service-token") fPolicy, _ := cmd.Flags().GetString("fleet-server-policy") fHost, _ := cmd.Flags().GetString("fleet-server-host") @@ -246,6 +256,7 @@ func enroll(streams *cli.IOStreams, cmd *cobra.Command, args []string) error { CertKey: fCertKey, Insecure: fInsecure, SpawnAgent: !fromInstall, + Headers: mapFromEnvList(fHeaders), }, } @@ -285,3 +296,16 @@ func handleSignal(ctx context.Context) context.Context { return ctx } + +func mapFromEnvList(envList []string) map[string]string { + m := make(map[string]string) + for _, kv := range envList { + keyValue := strings.SplitN(kv, "=", 2) + if len(keyValue) != 2 { + continue + } + + m[keyValue[0]] = keyValue[1] + } + return m +} diff --git a/x-pack/elastic-agent/pkg/agent/cmd/enroll_cmd.go b/x-pack/elastic-agent/pkg/agent/cmd/enroll_cmd.go index c7453f326f9..e170d9dea0f 100644 --- a/x-pack/elastic-agent/pkg/agent/cmd/enroll_cmd.go +++ b/x-pack/elastic-agent/pkg/agent/cmd/enroll_cmd.go @@ -79,6 +79,7 @@ type enrollCmdFleetServerOption struct { CertKey string Insecure bool SpawnAgent bool + Headers map[string]string } // enrollCmdOption define all the supported enrollment option. @@ -233,7 +234,8 @@ func (c *enrollCmd) fleetServerBootstrap(ctx context.Context) (string, error) { c.options.FleetServer.ConnStr, c.options.FleetServer.ServiceToken, c.options.FleetServer.PolicyID, c.options.FleetServer.Host, c.options.FleetServer.Port, - c.options.FleetServer.Cert, c.options.FleetServer.CertKey, c.options.FleetServer.ElasticsearchCA) + c.options.FleetServer.Cert, c.options.FleetServer.CertKey, c.options.FleetServer.ElasticsearchCA, + c.options.FleetServer.Headers) if err != nil { return "", err } @@ -413,7 +415,7 @@ func (c *enrollCmd) enroll(ctx context.Context, persistentConfig map[string]inte return err } - agentConfig, err := c.createAgentConfig(resp.Item.ID, persistentConfig) + agentConfig, err := c.createAgentConfig(resp.Item.ID, persistentConfig, c.options.FleetServer.Headers) if err != nil { return err } @@ -423,7 +425,8 @@ func (c *enrollCmd) enroll(ctx context.Context, persistentConfig map[string]inte c.options.FleetServer.ConnStr, c.options.FleetServer.ServiceToken, c.options.FleetServer.PolicyID, c.options.FleetServer.Host, c.options.FleetServer.Port, - c.options.FleetServer.Cert, c.options.FleetServer.CertKey, c.options.FleetServer.ElasticsearchCA) + c.options.FleetServer.Cert, c.options.FleetServer.CertKey, c.options.FleetServer.ElasticsearchCA, + c.options.FleetServer.Headers) if err != nil { return err } @@ -718,7 +721,12 @@ func storeAgentInfo(s saver, reader io.Reader) error { return nil } -func createFleetServerBootstrapConfig(connStr string, serviceToken string, policyID string, host string, port uint16, cert string, key string, esCA string) (*configuration.FleetAgentConfig, error) { +func createFleetServerBootstrapConfig( + connStr, serviceToken, policyID, host string, + port uint16, + cert, key, esCA string, + headers map[string]string, +) (*configuration.FleetAgentConfig, error) { es, err := configuration.ElasticsearchFromConnStr(connStr, serviceToken) if err != nil { return nil, err @@ -734,6 +742,15 @@ func createFleetServerBootstrapConfig(connStr string, serviceToken string, polic if port == 0 { port = defaultFleetServerPort } + if len(headers) > 0 { + if es.Headers == nil { + es.Headers = make(map[string]string) + } + // overwrites previously set headers + for k, v := range headers { + es.Headers[k] = v + } + } cfg := configuration.DefaultFleetAgentConfig() cfg.Enabled = true cfg.Server = &configuration.FleetServerConfig{ @@ -774,11 +791,15 @@ func createFleetConfigFromEnroll(accessAPIKey string, cli remote.Config) (*confi return cfg, nil } -func (c *enrollCmd) createAgentConfig(agentID string, pc map[string]interface{}) (map[string]interface{}, error) { +func (c *enrollCmd) createAgentConfig(agentID string, pc map[string]interface{}, headers map[string]string) (map[string]interface{}, error) { agentConfig := map[string]interface{}{ "id": agentID, } + if len(headers) > 0 { + agentConfig["headers"] = headers + } + if c.options.Staging != "" { staging := fmt.Sprintf("https://staging.elastic.co/%s-%s/downloads/", release.Version(), c.options.Staging[:8]) agentConfig["download"] = map[string]interface{}{ diff --git a/x-pack/elastic-agent/pkg/agent/cmd/setup_config.go b/x-pack/elastic-agent/pkg/agent/cmd/setup_config.go new file mode 100644 index 00000000000..4330c967e9f --- /dev/null +++ b/x-pack/elastic-agent/pkg/agent/cmd/setup_config.go @@ -0,0 +1,119 @@ +// 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 cmd + +import "time" + +// setup configuration + +type setupConfig struct { + Fleet fleetConfig `config:"fleet"` + FleetServer fleetServerConfig `config:"fleet_server"` + Kibana kibanaConfig `config:"kibana"` +} + +type fleetConfig struct { + CA string `config:"ca"` + Enroll bool `config:"enroll"` + EnrollmentToken string `config:"enrollment_token"` + Force bool `config:"force"` + Insecure bool `config:"insecure"` + TokenName string `config:"token_name"` + TokenPolicyName string `config:"token_policy_name"` + URL string `config:"url"` +} + +type fleetServerConfig struct { + Cert string `config:"cert"` + CertKey string `config:"cert_key"` + Elasticsearch elasticsearchConfig `config:"elasticsearch"` + Enable bool `config:"enable"` + Host string `config:"host"` + InsecureHTTP bool `config:"insecure_http"` + PolicyID string `config:"policy_id"` + Port string `config:"port"` + Headers map[string]string `config:"headers"` +} + +type elasticsearchConfig struct { + CA string `config:"ca"` + Host string `config:"host"` + Username string `config:"username"` + Password string `config:"password"` + ServiceToken string `config:"service_token"` +} + +type kibanaConfig struct { + Fleet kibanaFleetConfig `config:"fleet"` + RetrySleepDuration time.Duration `config:"retry_sleep_duration"` + RetryMaxCount int `config:"retry_max_count"` + Headers map[string]string `config:"headers"` +} + +type kibanaFleetConfig struct { + CA string `config:"ca"` + Host string `config:"host"` + Password string `config:"password"` + Setup bool `config:"setup"` + Username string `config:"username"` +} + +func defaultAccessConfig() (setupConfig, error) { + retrySleepDuration, err := envDurationWithDefault(defaultRequestRetrySleep, requestRetrySleepEnv) + if err != nil { + return setupConfig{}, err + } + + retryMaxCount, err := envIntWithDefault(defaultMaxRequestRetries, maxRequestRetriesEnv) + if err != nil { + return setupConfig{}, err + } + + cfg := setupConfig{ + Fleet: fleetConfig{ + CA: envWithDefault("", "FLEET_CA", "KIBANA_CA", "ELASTICSEARCH_CA"), + Enroll: envBool("FLEET_ENROLL", "FLEET_SERVER_ENABLE"), + EnrollmentToken: envWithDefault("", "FLEET_ENROLLMENT_TOKEN"), + Force: envBool("FLEET_FORCE"), + Insecure: envBool("FLEET_INSECURE"), + TokenName: envWithDefault("Default", "FLEET_TOKEN_NAME"), + TokenPolicyName: envWithDefault("", "FLEET_TOKEN_POLICY_NAME"), + URL: envWithDefault("", "FLEET_URL"), + }, + FleetServer: fleetServerConfig{ + Cert: envWithDefault("", "FLEET_SERVER_CERT"), + CertKey: envWithDefault("", "FLEET_SERVER_CERT_KEY"), + Elasticsearch: elasticsearchConfig{ + Host: envWithDefault("http://elasticsearch:9200", "FLEET_SERVER_ELASTICSEARCH_HOST", "ELASTICSEARCH_HOST"), + Username: envWithDefault("elastic", "FLEET_SERVER_ELASTICSEARCH_USERNAME", "ELASTICSEARCH_USERNAME"), + Password: envWithDefault("changeme", "FLEET_SERVER_ELASTICSEARCH_PASSWORD", "ELASTICSEARCH_PASSWORD"), + ServiceToken: envWithDefault("", "FLEET_SERVER_SERVICE_TOKEN"), + CA: envWithDefault("", "FLEET_SERVER_ELASTICSEARCH_CA", "ELASTICSEARCH_CA"), + }, + Enable: envBool("FLEET_SERVER_ENABLE"), + Host: envWithDefault("", "FLEET_SERVER_HOST"), + InsecureHTTP: envBool("FLEET_SERVER_INSECURE_HTTP"), + PolicyID: envWithDefault("", "FLEET_SERVER_POLICY_ID", "FLEET_SERVER_POLICY"), + Port: envWithDefault("", "FLEET_SERVER_PORT"), + Headers: envMap("FLEET_HEADER"), + }, + Kibana: kibanaConfig{ + Fleet: kibanaFleetConfig{ + // Remove FLEET_SETUP in 8.x + // The FLEET_SETUP environment variable boolean is a fallback to the old name. The name was updated to + // reflect that its setting up Fleet in Kibana versus setting up Fleet Server. + Setup: envBool("KIBANA_FLEET_SETUP", "FLEET_SETUP"), + Host: envWithDefault("http://kibana:5601", "KIBANA_FLEET_HOST", "KIBANA_HOST"), + Username: envWithDefault("elastic", "KIBANA_FLEET_USERNAME", "KIBANA_USERNAME", "ELASTICSEARCH_USERNAME"), + Password: envWithDefault("changeme", "KIBANA_FLEET_PASSWORD", "KIBANA_PASSWORD", "ELASTICSEARCH_PASSWORD"), + CA: envWithDefault("", "KIBANA_FLEET_CA", "KIBANA_CA", "ELASTICSEARCH_CA"), + }, + RetrySleepDuration: retrySleepDuration, + RetryMaxCount: retryMaxCount, + Headers: envMap("FLEET_KIBANA_HEADER"), + }, + } + return cfg, nil +} diff --git a/x-pack/elastic-agent/pkg/agent/configuration/fleet_server.go b/x-pack/elastic-agent/pkg/agent/configuration/fleet_server.go index e90f4bf3b1c..a87da18ecf2 100644 --- a/x-pack/elastic-agent/pkg/agent/configuration/fleet_server.go +++ b/x-pack/elastic-agent/pkg/agent/configuration/fleet_server.go @@ -40,6 +40,7 @@ type Elasticsearch struct { Password string `config:"password" yaml:"password,omitempty"` ServiceToken string `config:"service_token" yaml:"service_token,omitempty"` TLS *tlscommon.Config `config:"ssl" yaml:"ssl,omitempty"` + Headers map[string]string `config:"headers" yaml:"headers,omitempty"` } // ElasticsearchFromConnStr returns an Elasticsearch configuration from the connection string. diff --git a/x-pack/elastic-agent/pkg/agent/program/program_test.go b/x-pack/elastic-agent/pkg/agent/program/program_test.go index 2691aae9e41..4498f7e5236 100644 --- a/x-pack/elastic-agent/pkg/agent/program/program_test.go +++ b/x-pack/elastic-agent/pkg/agent/program/program_test.go @@ -499,3 +499,9 @@ func (*fakeAgentInfo) Version() string { func (*fakeAgentInfo) Snapshot() bool { return false } + +func (*fakeAgentInfo) Headers() map[string]string { + return map[string]string{ + "h1": "test-header", + } +} diff --git a/x-pack/elastic-agent/pkg/agent/program/supported.go b/x-pack/elastic-agent/pkg/agent/program/supported.go index 323d8e09f0f..9ff4eab7f10 100644 --- a/x-pack/elastic-agent/pkg/agent/program/supported.go +++ b/x-pack/elastic-agent/pkg/agent/program/supported.go @@ -25,7 +25,7 @@ func init() { // spec/metricbeat.yml // spec/osquerybeat.yml // spec/packetbeat.yml - unpacked := packer.MustUnpack("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") + unpacked := packer.MustUnpack("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") SupportedMap = make(map[string]Spec) for f, v := range unpacked { diff --git a/x-pack/elastic-agent/pkg/agent/transpiler/rules.go b/x-pack/elastic-agent/pkg/agent/transpiler/rules.go index 9135c751d3a..2afb312c930 100644 --- a/x-pack/elastic-agent/pkg/agent/transpiler/rules.go +++ b/x-pack/elastic-agent/pkg/agent/transpiler/rules.go @@ -19,6 +19,7 @@ type AgentInfo interface { AgentID() string Version() string Snapshot() bool + Headers() map[string]string } // RuleList is a container that allow the same tree to be executed on multiple defined Rule. @@ -90,6 +91,8 @@ func (r *RuleList) MarshalYAML() (interface{}, error) { name = "fix_stream" case *InsertDefaultsRule: name = "insert_defaults" + case *InjectHeadersRule: + name = "inject_headers" default: return nil, fmt.Errorf("unknown rule of type %T", rule) } @@ -175,6 +178,8 @@ func (r *RuleList) UnmarshalYAML(unmarshal func(interface{}) error) error { r = &FixStreamRule{} case "insert_defaults": r = &InsertDefaultsRule{} + case "inject_headers": + r = &InjectHeadersRule{} default: return fmt.Errorf("unknown rule of type %s", name) } @@ -1505,6 +1510,70 @@ func InsertDefaults(path string, selectors ...Selector) *InsertDefaultsRule { } } +// InjectHeadersRule injects headers into output. +type InjectHeadersRule struct{} + +// Apply injects headers into output. +func (r *InjectHeadersRule) Apply(agentInfo AgentInfo, ast *AST) (err error) { + defer func() { + if err != nil { + err = errors.New(err, "failed to inject headers into configuration") + } + }() + + headers := agentInfo.Headers() + if len(headers) == 0 { + return nil + } + + outputsNode, found := Lookup(ast, "outputs") + if !found { + return nil + } + + elasticsearchNode, found := outputsNode.Find("elasticsearch") + if found { + headersNode, found := elasticsearchNode.Find("headers") + if found { + headersDict, ok := headersNode.Value().(*Dict) + if !ok { + return errors.New("headers not a dictionary") + } + + for k, v := range headers { + headersDict.value = append(headersDict.value, &Key{ + name: k, + value: &StrVal{value: v}, + }) + } + } else { + nodes := make([]Node, 0, len(headers)) + for k, v := range headers { + nodes = append(nodes, &Key{ + name: k, + value: &StrVal{value: v}, + }) + } + headersDict := NewDict(nodes) + elasticsearchDict, ok := elasticsearchNode.Value().(*Dict) + if !ok { + return errors.New("elasticsearch output is not a dictionary") + } + elasticsearchDict.value = append(elasticsearchDict.value, &Key{ + name: "headers", + value: headersDict, + }) + } + } + + return nil +} + +// InjectHeaders creates a InjectHeadersRule +func InjectHeaders() *InjectHeadersRule { + return &InjectHeadersRule{} +} + // NewRuleList returns a new list of rules to be executed. func NewRuleList(rules ...Rule) *RuleList { return &RuleList{Rules: rules} diff --git a/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go b/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go index d6f24a8d8e3..71e12ac444b 100644 --- a/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go +++ b/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go @@ -685,6 +685,7 @@ rest: of }, }, }, + "insert defaults into not existing": { givenYAML: ` level_one: @@ -713,6 +714,65 @@ rest: of }, }, }, + + "inject auth headers: no headers": { + givenYAML: ` +outputs: + elasticsearch: + hosts: + - "127.0.0.1:9201" + - "127.0.0.1:9202" + logstash: + port: 5 +`, + expectedYAML: ` +outputs: + elasticsearch: + headers: + h1: test-header + hosts: + - "127.0.0.1:9201" + - "127.0.0.1:9202" + logstash: + port: 5 +`, + rule: &RuleList{ + Rules: []Rule{ + InjectHeaders(), + }, + }, + }, + + "inject auth headers: existing headers": { + givenYAML: ` +outputs: + elasticsearch: + headers: + sample-header: existing + hosts: + - "127.0.0.1:9201" + - "127.0.0.1:9202" + logstash: + port: 5 +`, + expectedYAML: ` +outputs: + elasticsearch: + headers: + sample-header: existing + h1: test-header + hosts: + - "127.0.0.1:9201" + - "127.0.0.1:9202" + logstash: + port: 5 +`, + rule: &RuleList{ + Rules: []Rule{ + InjectHeaders(), + }, + }, + }, } for name, test := range testcases { @@ -777,6 +837,7 @@ func TestSerialization(t *testing.T) { FixStream(), SelectInto("target", "s1", "s2"), InsertDefaults("target", "s1", "s2"), + InjectHeaders(), ) y := `- rename: @@ -847,6 +908,7 @@ func TestSerialization(t *testing.T) { - s1 - s2 path: target +- inject_headers: {} ` t.Run("serialize_rules", func(t *testing.T) { @@ -877,6 +939,12 @@ func (*fakeAgentInfo) Snapshot() bool { return false } +func (*fakeAgentInfo) Headers() map[string]string { + return map[string]string{ + "h1": "test-header", + } +} + func FakeAgentInfo() AgentInfo { return &fakeAgentInfo{} } diff --git a/x-pack/elastic-agent/spec/apm-server.yml b/x-pack/elastic-agent/spec/apm-server.yml index 67aac6349e3..c66a03e2bc7 100644 --- a/x-pack/elastic-agent/spec/apm-server.yml +++ b/x-pack/elastic-agent/spec/apm-server.yml @@ -31,4 +31,5 @@ rules: - inputs - output - fleet + - inject_headers: {} when: length(${inputs}) > 0 and hasKey(${output}, 'elasticsearch') diff --git a/x-pack/elastic-agent/spec/filebeat.yml b/x-pack/elastic-agent/spec/filebeat.yml index 8207c803284..6f47c1ebdee 100644 --- a/x-pack/elastic-agent/spec/filebeat.yml +++ b/x-pack/elastic-agent/spec/filebeat.yml @@ -106,5 +106,8 @@ rules: - filebeat - output - keystore + +- inject_headers: {} + when: length(${filebeat.inputs}) > 0 and hasKey(${output}, 'elasticsearch', 'redis', 'kafka', 'logstash') diff --git a/x-pack/elastic-agent/spec/fleet-server.yml b/x-pack/elastic-agent/spec/fleet-server.yml index 8cb80280842..abb4ad4a502 100644 --- a/x-pack/elastic-agent/spec/fleet-server.yml +++ b/x-pack/elastic-agent/spec/fleet-server.yml @@ -63,4 +63,6 @@ rules: - inputs - output + - inject_headers: {} + when: length(${fleet}) > 0 and length(${inputs}) > 0 and hasKey(${output}, 'elasticsearch') diff --git a/x-pack/elastic-agent/spec/metricbeat.yml b/x-pack/elastic-agent/spec/metricbeat.yml index 7968de13e8d..22e8d97f9c4 100644 --- a/x-pack/elastic-agent/spec/metricbeat.yml +++ b/x-pack/elastic-agent/spec/metricbeat.yml @@ -95,6 +95,7 @@ rules: - metricbeat - output - keystore +- inject_headers: {} when: length(${metricbeat.modules}) > 0 and hasKey(${output}, 'elasticsearch', 'redis', 'kafka', 'logstash') From 6347d455ead8b9af6bf8a49eaa9615f0e44d21e2 Mon Sep 17 00:00:00 2001 From: Chris Mark Date: Fri, 18 Jun 2021 16:41:23 +0300 Subject: [PATCH 03/20] Remove outdated k8s manifests for managed elastic-agent (#26368) Signed-off-by: chrismark --- deploy/kubernetes/Makefile | 2 +- .../kubernetes/elastic-agent-kubernetes.yaml | 146 ------------------ .../elastic-agent-daemonset.yaml | 44 ------ .../elastic-agent-deployment.yaml | 42 ----- .../elastic-agent-role-binding.yaml | 12 -- .../elastic-agent/elastic-agent-role.yaml | 36 ----- .../elastic-agent-service-account.yaml | 7 - 7 files changed, 1 insertion(+), 288 deletions(-) delete mode 100644 deploy/kubernetes/elastic-agent-kubernetes.yaml delete mode 100644 deploy/kubernetes/elastic-agent/elastic-agent-daemonset.yaml delete mode 100644 deploy/kubernetes/elastic-agent/elastic-agent-deployment.yaml delete mode 100644 deploy/kubernetes/elastic-agent/elastic-agent-role-binding.yaml delete mode 100644 deploy/kubernetes/elastic-agent/elastic-agent-role.yaml delete mode 100644 deploy/kubernetes/elastic-agent/elastic-agent-service-account.yaml diff --git a/deploy/kubernetes/Makefile b/deploy/kubernetes/Makefile index da1c7f92237..364b412b171 100644 --- a/deploy/kubernetes/Makefile +++ b/deploy/kubernetes/Makefile @@ -1,4 +1,4 @@ -ALL=filebeat metricbeat auditbeat heartbeat elastic-agent-standalone elastic-agent +ALL=filebeat metricbeat auditbeat heartbeat elastic-agent-standalone BEAT_VERSION=$(shell head -n 1 ../../libbeat/docs/version.asciidoc | cut -c 17- ) .PHONY: all $(ALL) diff --git a/deploy/kubernetes/elastic-agent-kubernetes.yaml b/deploy/kubernetes/elastic-agent-kubernetes.yaml deleted file mode 100644 index dae375c8e7f..00000000000 --- a/deploy/kubernetes/elastic-agent-kubernetes.yaml +++ /dev/null @@ -1,146 +0,0 @@ -apiVersion: apps/v1 -kind: DaemonSet -metadata: - name: agent-ingest-management-nodescope - namespace: kube-system - labels: - app: agent-ingest-management-nodescope - group: ingest-management -spec: - selector: - matchLabels: - app: agent-ingest-management-nodescope - template: - metadata: - labels: - app: agent-ingest-management-nodescope - group: ingest-management - spec: - serviceAccountName: agent-ingest-management - hostNetwork: true - dnsPolicy: ClusterFirstWithHostNet - containers: - - name: agent-ingest-management-nodescope - image: docker.elastic.co/beats/elastic-agent:8.0.0-SNAPSHOT - env: - - name: FLEET_ENROLL - value: "1" - # Use enrollment key of node scope configuration to distinguish node scope datasets - - name: FLEET_ENROLLMENT_TOKEN - value: - - name: KIBANA_HOST - value: "http://kibana:5601" - - name: NODE_NAME - valueFrom: - fieldRef: - fieldPath: spec.nodeName - securityContext: - runAsUser: 0 - resources: - limits: - memory: 200Mi - requests: - cpu: 100m - memory: 100Mi ---- -apiVersion: apps/v1 -kind: Deployment -metadata: - name: agent-ingest-management-clusterscope - namespace: kube-system - labels: - app: agent-ingest-management-clusterscope - group: ingest-management -spec: - selector: - matchLabels: - app: agent-ingest-management-clusterscope - template: - metadata: - labels: - app: agent-ingest-management-clusterscope - group: ingest-management - spec: - serviceAccountName: agent-ingest-management - containers: - - name: agent-ingest-management-clusterscope - image: docker.elastic.co/beats/elastic-agent:8.0.0-SNAPSHOT - env: - - name: FLEET_ENROLL - value: "1" - # Use enrollment key of cluster scope configuration to distinguish node scope datasets - - name: FLEET_ENROLLMENT_TOKEN - value: - - name: KIBANA_HOST - value: "http://kibana:5601" - - name: NODE_NAME - valueFrom: - fieldRef: - fieldPath: spec.nodeName - securityContext: - runAsUser: 0 - resources: - limits: - memory: 200Mi - requests: - cpu: 100m - memory: 100Mi ---- -apiVersion: rbac.authorization.k8s.io/v1 -kind: ClusterRoleBinding -metadata: - name: agent-ingest-management -subjects: - - kind: ServiceAccount - name: agent-ingest-management - namespace: kube-system -roleRef: - kind: ClusterRole - name: agent-ingest-management - apiGroup: rbac.authorization.k8s.io ---- -apiVersion: rbac.authorization.k8s.io/v1 -kind: ClusterRole -metadata: - name: agent-ingest-management - labels: - k8s-app: agent-ingest-management -rules: - - apiGroups: [""] - resources: - - nodes - - namespaces - - events - - pods - - secrets - verbs: ["get", "list", "watch"] - - apiGroups: ["extensions"] - resources: - - replicasets - verbs: ["get", "list", "watch"] - - apiGroups: ["apps"] - resources: - - statefulsets - - deployments - - replicasets - verbs: ["get", "list", "watch"] - - apiGroups: - - "" - resources: - - nodes/stats - verbs: - - get - # required for apiserver - - nonResourceURLs: - - "/metrics" - verbs: - - get ---- -apiVersion: v1 -kind: ServiceAccount -metadata: - name: agent-ingest-management - namespace: kube-system - labels: - k8s-app: agent-ingest-management ---- diff --git a/deploy/kubernetes/elastic-agent/elastic-agent-daemonset.yaml b/deploy/kubernetes/elastic-agent/elastic-agent-daemonset.yaml deleted file mode 100644 index 9dd5727d1f7..00000000000 --- a/deploy/kubernetes/elastic-agent/elastic-agent-daemonset.yaml +++ /dev/null @@ -1,44 +0,0 @@ -apiVersion: apps/v1 -kind: DaemonSet -metadata: - name: agent-ingest-management-nodescope - namespace: kube-system - labels: - app: agent-ingest-management-nodescope - group: ingest-management -spec: - selector: - matchLabels: - app: agent-ingest-management-nodescope - template: - metadata: - labels: - app: agent-ingest-management-nodescope - group: ingest-management - spec: - serviceAccountName: agent-ingest-management - hostNetwork: true - dnsPolicy: ClusterFirstWithHostNet - containers: - - name: agent-ingest-management-nodescope - image: docker.elastic.co/beats/elastic-agent:8.0.0-SNAPSHOT - env: - - name: FLEET_ENROLL - value: "1" - # Use enrollment key of node scope configuration to distinguish node scope datasets - - name: FLEET_ENROLLMENT_TOKEN - value: - - name: KIBANA_HOST - value: "http://kibana:5601" - - name: NODE_NAME - valueFrom: - fieldRef: - fieldPath: spec.nodeName - securityContext: - runAsUser: 0 - resources: - limits: - memory: 200Mi - requests: - cpu: 100m - memory: 100Mi diff --git a/deploy/kubernetes/elastic-agent/elastic-agent-deployment.yaml b/deploy/kubernetes/elastic-agent/elastic-agent-deployment.yaml deleted file mode 100644 index a1f026442db..00000000000 --- a/deploy/kubernetes/elastic-agent/elastic-agent-deployment.yaml +++ /dev/null @@ -1,42 +0,0 @@ -apiVersion: apps/v1 -kind: Deployment -metadata: - name: agent-ingest-management-clusterscope - namespace: kube-system - labels: - app: agent-ingest-management-clusterscope - group: ingest-management -spec: - selector: - matchLabels: - app: agent-ingest-management-clusterscope - template: - metadata: - labels: - app: agent-ingest-management-clusterscope - group: ingest-management - spec: - serviceAccountName: agent-ingest-management - containers: - - name: agent-ingest-management-clusterscope - image: docker.elastic.co/beats/elastic-agent:8.0.0-SNAPSHOT - env: - - name: FLEET_ENROLL - value: "1" - # Use enrollment key of cluster scope configuration to distinguish node scope datasets - - name: FLEET_ENROLLMENT_TOKEN - value: - - name: KIBANA_HOST - value: "http://kibana:5601" - - name: NODE_NAME - valueFrom: - fieldRef: - fieldPath: spec.nodeName - securityContext: - runAsUser: 0 - resources: - limits: - memory: 200Mi - requests: - cpu: 100m - memory: 100Mi diff --git a/deploy/kubernetes/elastic-agent/elastic-agent-role-binding.yaml b/deploy/kubernetes/elastic-agent/elastic-agent-role-binding.yaml deleted file mode 100644 index bc451c6adf3..00000000000 --- a/deploy/kubernetes/elastic-agent/elastic-agent-role-binding.yaml +++ /dev/null @@ -1,12 +0,0 @@ -apiVersion: rbac.authorization.k8s.io/v1 -kind: ClusterRoleBinding -metadata: - name: agent-ingest-management -subjects: - - kind: ServiceAccount - name: agent-ingest-management - namespace: kube-system -roleRef: - kind: ClusterRole - name: agent-ingest-management - apiGroup: rbac.authorization.k8s.io diff --git a/deploy/kubernetes/elastic-agent/elastic-agent-role.yaml b/deploy/kubernetes/elastic-agent/elastic-agent-role.yaml deleted file mode 100644 index 66b1bdc0437..00000000000 --- a/deploy/kubernetes/elastic-agent/elastic-agent-role.yaml +++ /dev/null @@ -1,36 +0,0 @@ -apiVersion: rbac.authorization.k8s.io/v1 -kind: ClusterRole -metadata: - name: agent-ingest-management - labels: - k8s-app: agent-ingest-management -rules: - - apiGroups: [""] - resources: - - nodes - - namespaces - - events - - pods - - secrets - verbs: ["get", "list", "watch"] - - apiGroups: ["extensions"] - resources: - - replicasets - verbs: ["get", "list", "watch"] - - apiGroups: ["apps"] - resources: - - statefulsets - - deployments - - replicasets - verbs: ["get", "list", "watch"] - - apiGroups: - - "" - resources: - - nodes/stats - verbs: - - get - # required for apiserver - - nonResourceURLs: - - "/metrics" - verbs: - - get diff --git a/deploy/kubernetes/elastic-agent/elastic-agent-service-account.yaml b/deploy/kubernetes/elastic-agent/elastic-agent-service-account.yaml deleted file mode 100644 index 107e4210814..00000000000 --- a/deploy/kubernetes/elastic-agent/elastic-agent-service-account.yaml +++ /dev/null @@ -1,7 +0,0 @@ -apiVersion: v1 -kind: ServiceAccount -metadata: - name: agent-ingest-management - namespace: kube-system - labels: - k8s-app: agent-ingest-management From ee3adfef67c3bba741eca724bd231209047b4a84 Mon Sep 17 00:00:00 2001 From: Jaime Soriano Pastor Date: Mon, 21 Jun 2021 15:58:19 +0200 Subject: [PATCH 04/20] Skip test_rotating_file in osx and windows (#26379) --- filebeat/tests/system/test_registrar.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/filebeat/tests/system/test_registrar.py b/filebeat/tests/system/test_registrar.py index 6a109070b80..be78cd044af 100644 --- a/filebeat/tests/system/test_registrar.py +++ b/filebeat/tests/system/test_registrar.py @@ -275,6 +275,8 @@ def test_registry_file_update_permissions(self): self.assertEqual(self.file_permissions(os.path.join(registry_path, "log.json")), "0o640") + @unittest.skipIf(platform.system() == 'Darwin' or os.name == 'nt', + 'Flaky test: https://github.com/elastic/beats/issues/26378') def test_rotating_file(self): """ Checks that the registry is properly updated after a file is rotated From 87994f47ac34c6e6a9a075c62900b2a6d7d1c6c2 Mon Sep 17 00:00:00 2001 From: Julien Mailleret <8582351+jmlrt@users.noreply.github.com> Date: Mon, 21 Jun 2021 16:44:26 +0200 Subject: [PATCH 05/20] Fix UBI source URL (#26384) This commit fix the source URL for UBI image to ensure that it stays consistent with the URL generated in https://artifacts.elastic.co/reports/dependencies/dependencies-current.html --- dev-tools/dependencies-report | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dev-tools/dependencies-report b/dev-tools/dependencies-report index 928de5367ca..5e0ec665df7 100755 --- a/dev-tools/dependencies-report +++ b/dev-tools/dependencies-report @@ -47,8 +47,8 @@ go list -m -json all $@ | go run go.elastic.co/go-licence-detector \ # Check headers in $SRCPATH/notice/dependencies.csv.tmpl: # name,url,version,revision,license ubi8url='https://catalog.redhat.com/software/containers/ubi8/ubi-minimal/5c359a62bed8bd75a2c3fba8' -ubi8source='https://oss-dependencies.elastic.co/redhat/ubi/ubi-minimal-8-source.tar.gz' +ubi8source='https://oss-dependencies.elastic.co/red-hat-universal-base-image-minimal/8/ubi-minimal-8-source.tar.gz' ubilicense='Custom;https://www.redhat.com/licenses/EULA_Red_Hat_Universal_Base_Image_English_20190422.pdf' cat <> $outfile -Red Hat Universal Base Image,$ubi8url,8,,$ubilicense,$ubi8source +Red Hat Universal Base Image minimal,$ubi8url,8,,$ubilicense,$ubi8source EOF From c55c73c78baee668d75d78762d02cd3d37cc24a2 Mon Sep 17 00:00:00 2001 From: Andrew Kroh Date: Mon, 21 Jun 2021 15:27:08 -0400 Subject: [PATCH 06/20] Mark MISP module deprecated (#26174) Add deprecation notice to docs for the MISP module. The threat intel module should be used instead. Closes #25240 --- CHANGELOG.next.asciidoc | 1 + filebeat/docs/modules/misp.asciidoc | 2 ++ x-pack/filebeat/filebeat.reference.yml | 2 ++ x-pack/filebeat/module/misp/_meta/config.yml | 2 ++ x-pack/filebeat/module/misp/_meta/docs.asciidoc | 2 ++ x-pack/filebeat/modules.d/misp.yml.disabled | 2 ++ 6 files changed, 11 insertions(+) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 70f6f7f6393..9ba9149e252 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -1012,6 +1012,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d *Filebeat* +- Deprecate the MISP module. The Threat Intel module should be used instead. {issue}25240[25240] *Heartbeat* diff --git a/filebeat/docs/modules/misp.asciidoc b/filebeat/docs/modules/misp.asciidoc index 4eebc6150c4..b38ec8c0a66 100644 --- a/filebeat/docs/modules/misp.asciidoc +++ b/filebeat/docs/modules/misp.asciidoc @@ -10,6 +10,8 @@ This file is generated! See scripts/docs_collector.py == MISP module +deprecated::[7.14.0,"This module is deprecated. Use the <> instead."] + beta[] This is a filebeat module for reading threat intel information from the MISP platform (https://www.circl.lu/doc/misp/). It uses the httpjson input to access the MISP REST API interface. diff --git a/x-pack/filebeat/filebeat.reference.yml b/x-pack/filebeat/filebeat.reference.yml index 755fd914777..eb54d2f62b9 100644 --- a/x-pack/filebeat/filebeat.reference.yml +++ b/x-pack/filebeat/filebeat.reference.yml @@ -1537,6 +1537,8 @@ filebeat.modules: # var.tz_offset: local #--------------------------------- MISP Module --------------------------------- +# Deprecated in 7.14.0: Recommended to migrate to the Threat Intel module. + - module: misp threat: enabled: true diff --git a/x-pack/filebeat/module/misp/_meta/config.yml b/x-pack/filebeat/module/misp/_meta/config.yml index 67c7dc566d8..0eab72db205 100644 --- a/x-pack/filebeat/module/misp/_meta/config.yml +++ b/x-pack/filebeat/module/misp/_meta/config.yml @@ -1,3 +1,5 @@ +# Deprecated in 7.14.0: Recommended to migrate to the Threat Intel module. + - module: misp threat: enabled: true diff --git a/x-pack/filebeat/module/misp/_meta/docs.asciidoc b/x-pack/filebeat/module/misp/_meta/docs.asciidoc index ea0e671c06b..7025f65d7d9 100644 --- a/x-pack/filebeat/module/misp/_meta/docs.asciidoc +++ b/x-pack/filebeat/module/misp/_meta/docs.asciidoc @@ -5,6 +5,8 @@ == MISP module +deprecated::[7.14.0,"This module is deprecated. Use the <> instead."] + beta[] This is a filebeat module for reading threat intel information from the MISP platform (https://www.circl.lu/doc/misp/). It uses the httpjson input to access the MISP REST API interface. diff --git a/x-pack/filebeat/modules.d/misp.yml.disabled b/x-pack/filebeat/modules.d/misp.yml.disabled index 25cbaf6b1b8..610cc874073 100644 --- a/x-pack/filebeat/modules.d/misp.yml.disabled +++ b/x-pack/filebeat/modules.d/misp.yml.disabled @@ -1,6 +1,8 @@ # Module: misp # Docs: https://www.elastic.co/guide/en/beats/filebeat/master/filebeat-module-misp.html +# Deprecated in 7.14.0: Recommended to migrate to the Threat Intel module. + - module: misp threat: enabled: true From dda9f353f1203da243bd76baf53d2e83b6f26c1a Mon Sep 17 00:00:00 2001 From: Marc Guasch Date: Tue, 22 Jun 2021 08:45:03 +0200 Subject: [PATCH 07/20] Populate event.original with the original json bytes (#26355) --- .../filebeat/input/o365audit/contentblob.go | 25 ++++++++++++------- x-pack/filebeat/input/o365audit/input.go | 9 ++++--- x-pack/filebeat/input/o365audit/input_test.go | 6 +++-- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/x-pack/filebeat/input/o365audit/contentblob.go b/x-pack/filebeat/input/o365audit/contentblob.go index 0eca809b637..8ac344df44f 100644 --- a/x-pack/filebeat/input/o365audit/contentblob.go +++ b/x-pack/filebeat/input/o365audit/contentblob.go @@ -5,6 +5,7 @@ package o365audit import ( + "encoding/json" "fmt" "net/http" "time" @@ -50,33 +51,39 @@ func (c contentBlob) OnResponse(response *http.Response) (actions []poll.Action) if response.StatusCode != 200 { return c.handleError(response) } - var js []common.MapStr - if err := readJSONBody(response, &js); err != nil { + var raws []json.RawMessage + if err := readJSONBody(response, &raws); err != nil { return append(actions, poll.Terminate(errors.Wrap(err, "reading body failed"))) } - for idx, entry := range js { + entries := make([]common.MapStr, len(raws)) + for idx, raw := range raws { + var entry common.MapStr + if err := json.Unmarshal(raw, &entry); err != nil { + return append(actions, poll.Terminate(errors.Wrap(err, "decoding json failed"))) + } + entries[idx] = entry id, _ := getString(entry, "Id") ts, _ := getString(entry, "CreationTime") c.env.Logger.Debugf(" > event %d: created:%s id:%s for %s", idx+1, ts, id, c.cursor) } - if len(js) > c.skipLines { - for _, entry := range js[:c.skipLines] { + if len(entries) > c.skipLines { + for _, entry := range entries[:c.skipLines] { id, _ := getString(entry, "Id") c.env.Logger.Debugf("Skipping event %s [%s] for %s", c.cursor, id, c.id) } - for _, entry := range js[c.skipLines:] { + for idx, entry := range entries[c.skipLines:] { c.cursor = c.cursor.ForNextLine() c.env.Logger.Debugf("Reporting event %s for %s", c.cursor, c.id) - actions = append(actions, c.env.Report(entry, c.cursor)) + actions = append(actions, c.env.Report(raws[idx], entry, c.cursor)) } c.skipLines = 0 } else { - for _, entry := range js { + for _, entry := range entries { id, _ := getString(entry, "Id") c.env.Logger.Debugf("Skipping event all %s [%s] for %s", c.cursor, id, c.id) } - c.skipLines -= len(js) + c.skipLines -= len(entries) } // The API only documents the use of NextPageUri header for list requests // but one can't be too careful. diff --git a/x-pack/filebeat/input/o365audit/input.go b/x-pack/filebeat/input/o365audit/input.go index 5be035fd489..99bbf79ec1b 100644 --- a/x-pack/filebeat/input/o365audit/input.go +++ b/x-pack/filebeat/input/o365audit/input.go @@ -6,6 +6,7 @@ package o365audit import ( "context" + "encoding/json" "time" "github.com/Azure/go-autorest/autorest" @@ -222,9 +223,9 @@ func initCheckpoint(log *logp.Logger, c cursor.Cursor, maxRetention time.Duratio } // Report returns an action that produces a beat.Event from the given object. -func (env apiEnvironment) Report(doc common.MapStr, private interface{}) poll.Action { +func (env apiEnvironment) Report(raw json.RawMessage, doc common.MapStr, private interface{}) poll.Action { return func(poll.Enqueuer) error { - return env.Callback(env.toBeatEvent(doc), private) + return env.Callback(env.toBeatEvent(raw, doc), private) } } @@ -235,7 +236,7 @@ func (env apiEnvironment) ReportAPIError(err apiError) poll.Action { } } -func (env apiEnvironment) toBeatEvent(doc common.MapStr) beat.Event { +func (env apiEnvironment) toBeatEvent(raw json.RawMessage, doc common.MapStr) beat.Event { var errs multierror.Errors ts, err := getDateKey(doc, "CreationTime", apiDateFormats) if err != nil { @@ -254,7 +255,7 @@ func (env apiEnvironment) toBeatEvent(doc common.MapStr) beat.Event { } } if env.Config.PreserveOriginalEvent { - b.PutValue("event.original", doc.String()) + b.PutValue("event.original", string(raw)) } if len(errs) > 0 { msgs := make([]string, len(errs)) diff --git a/x-pack/filebeat/input/o365audit/input_test.go b/x-pack/filebeat/input/o365audit/input_test.go index a84c58544dd..ce95c4c7770 100644 --- a/x-pack/filebeat/input/o365audit/input_test.go +++ b/x-pack/filebeat/input/o365audit/input_test.go @@ -5,6 +5,7 @@ package o365audit import ( + "encoding/json" "testing" "github.com/stretchr/testify/assert" @@ -18,11 +19,12 @@ func TestPreserveOriginalEvent(t *testing.T) { Config: APIConfig{PreserveOriginalEvent: false}, } + raw := json.RawMessage(`{"field1":"val1"}`) doc := common.MapStr{ "field1": "val1", } - event := env.toBeatEvent(doc) + event := env.toBeatEvent(raw, doc) v, err := event.GetValue("event.original") require.EqualError(t, err, "key not found") @@ -30,7 +32,7 @@ func TestPreserveOriginalEvent(t *testing.T) { env.Config.PreserveOriginalEvent = true - event = env.toBeatEvent(doc) + event = env.toBeatEvent(raw, doc) v, err = event.GetValue("event.original") require.NoError(t, err) From 0b729af108edb94777202bbefd5139b7f1c69925 Mon Sep 17 00:00:00 2001 From: Marc Guasch Date: Tue, 22 Jun 2021 15:47:49 +0200 Subject: [PATCH 08/20] Fix httpjson first_event (#26407) --- CHANGELOG.next.asciidoc | 1 + .../input/httpjson/internal/v2/input_test.go | 55 +++++++++++++++++-- .../input/httpjson/internal/v2/request.go | 2 + .../httpjson/internal/v2/request_test.go | 3 +- .../input/httpjson/internal/v2/transform.go | 8 +++ 5 files changed, 63 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 9ba9149e252..220cd1c03d9 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -275,6 +275,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - 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] - Fix bug in aws-s3 input where the end of gzipped log files might have been discarded. {pull}26260[26260] +- Fix bug in `httpjson` that prevented `first_event` getting updated. {pull}26407[26407] *Filebeat* diff --git a/x-pack/filebeat/input/httpjson/internal/v2/input_test.go b/x-pack/filebeat/input/httpjson/internal/v2/input_test.go index 24ddfb7bbed..bbfdb1e5357 100644 --- a/x-pack/filebeat/input/httpjson/internal/v2/input_test.go +++ b/x-pack/filebeat/input/httpjson/internal/v2/input_test.go @@ -215,7 +215,7 @@ func TestInput(t *testing.T) { t.Cleanup(server.Close) }, baseConfig: map[string]interface{}{ - "interval": 1, + "interval": time.Second, "request.method": "GET", "response.split": map[string]interface{}{ "target": "body.items", @@ -230,7 +230,50 @@ func TestInput(t *testing.T) { }, }, handler: paginationHandler(), - expected: []string{`{"foo":"bar"}`, `{"foo":"bar"}`}, + expected: []string{`{"foo":"a"}`, `{"foo":"b"}`}, + }, + { + name: "Test first event", + setupServer: func(t *testing.T, h http.HandlerFunc, config map[string]interface{}) { + registerPaginationTransforms() + registerResponseTransforms() + t.Cleanup(func() { registeredTransforms = newRegistry() }) + server := httptest.NewServer(h) + config["request.url"] = server.URL + t.Cleanup(server.Close) + }, + baseConfig: map[string]interface{}{ + "interval": 1, + "request.method": "GET", + "response.split": map[string]interface{}{ + "target": "body.items", + "transforms": []interface{}{ + map[string]interface{}{ + "set": map[string]interface{}{ + "target": "body.first", + "value": "[[.cursor.first]]", + "default": "none", + }, + }, + }, + }, + "response.pagination": []interface{}{ + map[string]interface{}{ + "set": map[string]interface{}{ + "target": "url.params.page", + "value": "[[.last_response.body.nextPageToken]]", + "fail_on_template_error": true, + }, + }, + }, + "cursor": map[string]interface{}{ + "first": map[string]interface{}{ + "value": "[[.first_event.foo]]", + }, + }, + }, + handler: paginationHandler(), + expected: []string{`{"first":"none", "foo":"a"}`, `{"first":"a", "foo":"b"}`, `{"first":"a", "foo":"c"}`, `{"first":"c", "foo":"d"}`}, }, { name: "Test pagination with array response", @@ -492,14 +535,18 @@ func paginationHandler() http.HandlerFunc { w.Header().Set("content-type", "application/json") switch count { case 0: - _, _ = w.Write([]byte(`{"@timestamp":"2002-10-02T15:00:00Z","nextPageToken":"bar","items":[{"foo":"bar"}]}`)) + _, _ = w.Write([]byte(`{"@timestamp":"2002-10-02T15:00:00Z","nextPageToken":"bar","items":[{"foo":"a"}]}`)) case 1: if r.URL.Query().Get("page") != "bar" { w.WriteHeader(http.StatusBadRequest) _, _ = w.Write([]byte(`{"error":"wrong page token value"}`)) return } - _, _ = w.Write([]byte(`{"@timestamp":"2002-10-02T15:00:01Z","items":[{"foo":"bar"}]}`)) + _, _ = w.Write([]byte(`{"@timestamp":"2002-10-02T15:00:01Z","items":[{"foo":"b"}]}`)) + case 2: + _, _ = w.Write([]byte(`{"@timestamp":"2002-10-02T15:00:02Z","items":[{"foo":"c"}]}`)) + case 3: + _, _ = w.Write([]byte(`{"@timestamp":"2002-10-02T15:00:03Z","items":[{"foo":"d"}]}`)) } count += 1 } diff --git a/x-pack/filebeat/input/httpjson/internal/v2/request.go b/x-pack/filebeat/input/httpjson/internal/v2/request.go index c02cab5be8b..6c223d746a9 100644 --- a/x-pack/filebeat/input/httpjson/internal/v2/request.go +++ b/x-pack/filebeat/input/httpjson/internal/v2/request.go @@ -180,6 +180,8 @@ func (r *requester) doRequest(stdCtx context.Context, trCtx *transformContext, p return err } + trCtx.clearIntervalData() + var n int for maybeMsg := range eventsCh { if maybeMsg.failed() { diff --git a/x-pack/filebeat/input/httpjson/internal/v2/request_test.go b/x-pack/filebeat/input/httpjson/internal/v2/request_test.go index 0fc5be78930..f6564af3ed0 100644 --- a/x-pack/filebeat/input/httpjson/internal/v2/request_test.go +++ b/x-pack/filebeat/input/httpjson/internal/v2/request_test.go @@ -110,10 +110,9 @@ func TestCtxAfterDoRequest(t *testing.T) { trCtx.cursorMap(), ) - // this does not change assert.EqualValues( t, - &common.MapStr{"@timestamp": "2002-10-02T15:00:00Z", "foo": "bar"}, + &common.MapStr{"@timestamp": "2002-10-02T15:00:01Z", "foo": "bar"}, trCtx.firstEventClone(), ) diff --git a/x-pack/filebeat/input/httpjson/internal/v2/transform.go b/x-pack/filebeat/input/httpjson/internal/v2/transform.go index 440181cccd4..d6cf4b248cd 100644 --- a/x-pack/filebeat/input/httpjson/internal/v2/transform.go +++ b/x-pack/filebeat/input/httpjson/internal/v2/transform.go @@ -96,6 +96,14 @@ func (ctx *transformContext) updateLastResponse(r response) { *ctx.lastResponse = r } +func (ctx *transformContext) clearIntervalData() { + ctx.lock.Lock() + defer ctx.lock.Unlock() + ctx.lastEvent = &common.MapStr{} + ctx.firstEvent = &common.MapStr{} + ctx.lastResponse = &response{} +} + type transformable common.MapStr func (tr transformable) access() common.MapStr { From 4c51cfd1719b8e3a264089d852333e5c32793e3f Mon Sep 17 00:00:00 2001 From: Aleksandr Maus Date: Tue, 22 Jun 2021 08:57:30 -0700 Subject: [PATCH 09/20] Osquerybeat: fix arm64 packaging (#26374) * Osquerybeat: fix arm64 packaging * Add package-arm * Add debugging traces * Rename variable * Do not need osquerybeat docker image, since it's not running standalone * Revert Co-authored-by: Victor Martinez --- .ci/packaging.groovy | 1 - x-pack/osquerybeat/magefile.go | 5 ----- 2 files changed, 6 deletions(-) diff --git a/.ci/packaging.groovy b/.ci/packaging.groovy index fbeca246e2e..6b41838ce45 100644 --- a/.ci/packaging.groovy +++ b/.ci/packaging.groovy @@ -212,7 +212,6 @@ pipeline { 'x-pack/filebeat', 'x-pack/heartbeat', 'x-pack/metricbeat', - 'x-pack/osquerybeat', 'x-pack/packetbeat' ) } diff --git a/x-pack/osquerybeat/magefile.go b/x-pack/osquerybeat/magefile.go index ac0c920502a..583b3e917cb 100644 --- a/x-pack/osquerybeat/magefile.go +++ b/x-pack/osquerybeat/magefile.go @@ -98,11 +98,6 @@ func CrossBuild() error { return err } - if runtime.GOARCH != "amd64" { - fmt.Println("Crossbuilding functions only works on amd64 architecture.") - return nil - } - err = devtools.CrossBuild(devtools.InDir("x-pack", "osquerybeat", "ext", "osquery-extension")) if err != nil { return err From bb950bf633d32956c743acdd9da135322a35489c Mon Sep 17 00:00:00 2001 From: Andrew Kroh Date: Tue, 22 Jun 2021 12:39:24 -0400 Subject: [PATCH 10/20] [Elastic Agent] Use Fleet agent ID as agent.id (#26394) This updates the inject_agent_info rule to set the `agent.id` field to the value of the Fleet Agent ID. Previously this value was only added to the `elastic_agent.id` field, and the `agent.id` field was a random UUID generated the first time a Beat process was run. And each Beat process would have its own UUID. This change affects metricbeat, filebeat, heartbeat, osquerybeat, and packetbeat (these are the Beats that have an integration with Agent today). Heartbeat's Agent spec was missing the `inject_agent_info` so I added it. Closes #21121 --- x-pack/elastic-agent/CHANGELOG.next.asciidoc | 1 + .../pkg/agent/program/supported.go | 2 +- .../testdata/enabled_output_true-filebeat.yml | 4 +++ .../testdata/enabled_true-filebeat.yml | 4 +++ .../testdata/single_config-filebeat.yml | 8 +++++ .../testdata/single_config-heartbeat.yml | 11 +++++++ .../testdata/single_config-metricbeat.yml | 12 +++++++ .../testdata/single_config-packetbeat.yml | 4 +++ .../testdata/synthetics_config-heartbeat.yml | 33 +++++++++++++++++++ .../pkg/agent/transpiler/rules.go | 11 ++++++- .../pkg/agent/transpiler/rules_test.go | 8 +++++ x-pack/elastic-agent/spec/heartbeat.yml | 1 + 12 files changed, 97 insertions(+), 2 deletions(-) diff --git a/x-pack/elastic-agent/CHANGELOG.next.asciidoc b/x-pack/elastic-agent/CHANGELOG.next.asciidoc index fd1556ca0ce..b1f7ecdce12 100644 --- a/x-pack/elastic-agent/CHANGELOG.next.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.next.asciidoc @@ -112,3 +112,4 @@ - Log output of container to $LOGS_PATH/elastic-agent-start.log when LOGS_PATH set {pull}25150[25150] - Use `filestream` input for internal log collection. {pull}25660[25660] - Enable agent to send custom headers to kibana/ES {pull}26275[26275] +- Set `agent.id` to the Fleet Agent ID in events published from inputs backed by Beats. {issue}21121[21121] {pull}26394[26394] diff --git a/x-pack/elastic-agent/pkg/agent/program/supported.go b/x-pack/elastic-agent/pkg/agent/program/supported.go index 9ff4eab7f10..3d34d953e67 100644 --- a/x-pack/elastic-agent/pkg/agent/program/supported.go +++ b/x-pack/elastic-agent/pkg/agent/program/supported.go @@ -25,7 +25,7 @@ func init() { // spec/metricbeat.yml // spec/osquerybeat.yml // spec/packetbeat.yml - unpacked := packer.MustUnpack("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") + unpacked := packer.MustUnpack("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") SupportedMap = make(map[string]Spec) for f, v := range unpacked { diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_output_true-filebeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_output_true-filebeat.yml index 82a47adc999..42029b454a4 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_output_true-filebeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_output_true-filebeat.yml @@ -22,6 +22,10 @@ filebeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id output: elasticsearch: enabled: true diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_true-filebeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_true-filebeat.yml index 1406a2dff65..6a3cab074ea 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_true-filebeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/enabled_true-filebeat.yml @@ -23,6 +23,10 @@ filebeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id output: elasticsearch: hosts: diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-filebeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-filebeat.yml index 524d6451f28..1294b44bb49 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-filebeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-filebeat.yml @@ -24,6 +24,10 @@ filebeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id - type: log paths: - /var/log/hello3.log @@ -48,6 +52,10 @@ filebeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id output: elasticsearch: hosts: diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-heartbeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-heartbeat.yml index 76bad6aeeb7..a397f3a90df 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-heartbeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-heartbeat.yml @@ -7,6 +7,17 @@ inputs: timeout: 16s wait: 1s data_stream.namespace: default + processors: + - add_fields: + target: 'elastic_agent' + fields: + id: agent-id + version: 8.0.0 + snapshot: false + - add_fields: + target: 'agent' + fields: + id: agent-id output: elasticsearch: hosts: diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-metricbeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-metricbeat.yml index 2889e7605eb..b56834faacc 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-metricbeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-metricbeat.yml @@ -21,6 +21,10 @@ metricbeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id - module: docker metricsets: [info] index: metrics-generic-default @@ -42,6 +46,10 @@ metricbeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id - module: apache metricsets: [info] index: metrics-generic-testing @@ -66,6 +74,10 @@ metricbeat: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: "agent" + fields: + id: agent-id output: elasticsearch: hosts: [127.0.0.1:9200, 127.0.0.1:9300] diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-packetbeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-packetbeat.yml index f451ad93ddb..879ed127a0c 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-packetbeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/single_config-packetbeat.yml @@ -7,6 +7,10 @@ inputs: id: agent-id version: 8.0.0 snapshot: false + - add_fields: + target: 'agent' + fields: + id: agent-id streams: - type: flow timeout: 10s diff --git a/x-pack/elastic-agent/pkg/agent/program/testdata/synthetics_config-heartbeat.yml b/x-pack/elastic-agent/pkg/agent/program/testdata/synthetics_config-heartbeat.yml index c9af2356e12..284d391f78b 100644 --- a/x-pack/elastic-agent/pkg/agent/program/testdata/synthetics_config-heartbeat.yml +++ b/x-pack/elastic-agent/pkg/agent/program/testdata/synthetics_config-heartbeat.yml @@ -7,6 +7,17 @@ inputs: timeout: 16s wait: 1s data_stream.namespace: default + processors: + - add_fields: + target: 'elastic_agent' + fields: + id: agent-id + version: 8.0.0 + snapshot: false + - add_fields: + target: 'agent' + fields: + id: agent-id - type: synthetics/tcp id: unique-tcp-id name: my-tcp @@ -15,6 +26,17 @@ inputs: timeout: 16s wait: 1s data_stream.namespace: default + processors: + - add_fields: + target: 'elastic_agent' + fields: + id: agent-id + version: 8.0.0 + snapshot: false + - add_fields: + target: 'agent' + fields: + id: agent-id - type: synthetics/icmp id: unique-icmp-id name: my-icmp @@ -26,6 +48,17 @@ inputs: timeout: 16s wait: 1s data_stream.namespace: default + processors: + - add_fields: + target: 'elastic_agent' + fields: + id: agent-id + version: 8.0.0 + snapshot: false + - add_fields: + target: 'agent' + fields: + id: agent-id output: elasticsearch: hosts: [127.0.0.1:9200, 127.0.0.1:9300] diff --git a/x-pack/elastic-agent/pkg/agent/transpiler/rules.go b/x-pack/elastic-agent/pkg/agent/transpiler/rules.go index 2afb312c930..b09477c169f 100644 --- a/x-pack/elastic-agent/pkg/agent/transpiler/rules.go +++ b/x-pack/elastic-agent/pkg/agent/transpiler/rules.go @@ -775,7 +775,7 @@ func (r *InjectAgentInfoRule) Apply(agentInfo AgentInfo, ast *AST) (err error) { return errors.New("InjectAgentInfoRule: processors is not a list") } - // elastic.agent + // elastic_agent processorMap := &Dict{value: make([]Node, 0)} processorMap.value = append(processorMap.value, &Key{name: "target", value: &StrVal{value: "elastic_agent"}}) processorMap.value = append(processorMap.value, &Key{name: "fields", value: &Dict{value: []Node{ @@ -785,6 +785,15 @@ func (r *InjectAgentInfoRule) Apply(agentInfo AgentInfo, ast *AST) (err error) { }}}) addFieldsMap := &Dict{value: []Node{&Key{"add_fields", processorMap}}} processorsList.value = mergeStrategy("").InjectItem(processorsList.value, addFieldsMap) + + // agent.id + processorMap = &Dict{value: make([]Node, 0)} + processorMap.value = append(processorMap.value, &Key{name: "target", value: &StrVal{value: "agent"}}) + processorMap.value = append(processorMap.value, &Key{name: "fields", value: &Dict{value: []Node{ + &Key{name: "id", value: &StrVal{value: agentInfo.AgentID()}}, + }}}) + addFieldsMap = &Dict{value: []Node{&Key{"add_fields", processorMap}}} + processorsList.value = mergeStrategy("").InjectItem(processorsList.value, addFieldsMap) } return nil diff --git a/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go b/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go index 71e12ac444b..ad551822cf3 100644 --- a/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go +++ b/x-pack/elastic-agent/pkg/agent/transpiler/rules_test.go @@ -189,6 +189,10 @@ inputs: id: agent-id snapshot: false version: 8.0.0 + - add_fields: + target: agent + fields: + id: agent-id - name: With processors type: file processors: @@ -202,6 +206,10 @@ inputs: id: agent-id snapshot: false version: 8.0.0 + - add_fields: + target: agent + fields: + id: agent-id `, rule: &RuleList{ Rules: []Rule{ diff --git a/x-pack/elastic-agent/spec/heartbeat.yml b/x-pack/elastic-agent/spec/heartbeat.yml index adb0c414f10..ecb373cf791 100644 --- a/x-pack/elastic-agent/spec/heartbeat.yml +++ b/x-pack/elastic-agent/spec/heartbeat.yml @@ -14,6 +14,7 @@ rules: key: enabled values: - true + - inject_agent_info: {} - filter: selectors: - inputs From 794df17de660e84fb2e03e47946607b8fd30ed8e Mon Sep 17 00:00:00 2001 From: Marius Iversen Date: Tue, 22 Jun 2021 19:07:57 +0200 Subject: [PATCH 11/20] [http_endpoint input] Add support for including headers and preserving original events (#26279) * adding header support and event.original for the http_endpoint input * add changelog * updating docs * adding tests * applying comments from PR * adding more tests, and applying changes related to PR comments * linting * stashing changes * small changes * Linting * adding comments from PR --- CHANGELOG.next.asciidoc | 1 + .../docs/inputs/input-http-endpoint.asciidoc | 25 ++ x-pack/filebeat/input/http_endpoint/config.go | 44 ++-- .../filebeat/input/http_endpoint/handler.go | 115 +++++++-- .../input/http_endpoint/handler_test.go | 95 ++++--- x-pack/filebeat/input/http_endpoint/input.go | 12 +- .../tests/system/test_http_endpoint.py | 241 +++++++++++++++--- 7 files changed, 423 insertions(+), 110 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 220cd1c03d9..d5b2edf2e3d 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -819,6 +819,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 possibility to include headers in resulting docs and preserve the original event in http_endpoint input {pull}26279[26279] - Add `preserve_original_event` option to `o365audit` input. {pull}26273[26273] - Add `log.flags` to events created by the `aws-s3` input. {pull}26267[26267] - Add `include_s3_metadata` config option to the `aws-s3` input for including object metadata in events. {pull}26267[26267] diff --git a/x-pack/filebeat/docs/inputs/input-http-endpoint.asciidoc b/x-pack/filebeat/docs/inputs/input-http-endpoint.asciidoc index 9740de9e936..0394c1bc99f 100644 --- a/x-pack/filebeat/docs/inputs/input-http-endpoint.asciidoc +++ b/x-pack/filebeat/docs/inputs/input-http-endpoint.asciidoc @@ -96,6 +96,18 @@ Validate a HMAC signature from a specific header hmac.prefix: "sha256=" ---- +Preserving original event and including headers in document +["source","yaml",subs="attributes"] +---- +{beatname_lc}.inputs: +- type: http_endpoint + enabled: true + listen_address: 192.168.1.1 + listen_port: 8080 + preserve_original_event: true + include_headers: ["TestHeader"] +---- + ==== Configuration options The `http_endpoint` input supports the following configuration options plus the @@ -182,6 +194,19 @@ This options specific which URL path to accept requests on. Defaults to `/` This option specifies which prefix the incoming request will be mapped to. +[float] +==== `include_headers` + +This options specifies a list of HTTP headers that should be copied from the incoming request and included in the document. +All configured headers will always be canonicalized to match the headers of the incoming request. +For example, `["content-type"]` will become `["Content-Type"]` when the filebeat is running. + +[float] +==== `preserve_original_event` + +This option copies the raw unmodified body of the incoming request to the event.original field as a string before sending the event to Elasticsearch. + + [id="{beatname_lc}-input-{type}-common-options"] include::../../../../filebeat/docs/inputs/input-common-options.asciidoc[] diff --git a/x-pack/filebeat/input/http_endpoint/config.go b/x-pack/filebeat/input/http_endpoint/config.go index 71c23bdb041..bd49e8f0a07 100644 --- a/x-pack/filebeat/input/http_endpoint/config.go +++ b/x-pack/filebeat/input/http_endpoint/config.go @@ -7,29 +7,32 @@ package http_endpoint import ( "encoding/json" "errors" + "net/textproto" "github.com/elastic/beats/v7/libbeat/common/transport/tlscommon" ) // Config contains information about httpjson configuration type config struct { - TLS *tlscommon.ServerConfig `config:"ssl"` - BasicAuth bool `config:"basic_auth"` - Username string `config:"username"` - Password string `config:"password"` - ResponseCode int `config:"response_code" validate:"positive"` - ResponseBody string `config:"response_body"` - ListenAddress string `config:"listen_address"` - ListenPort string `config:"listen_port"` - URL string `config:"url"` - Prefix string `config:"prefix"` - ContentType string `config:"content_type"` - SecretHeader string `config:"secret.header"` - SecretValue string `config:"secret.value"` - HMACHeader string `config:"hmac.header"` - HMACKey string `config:"hmac.key"` - HMACType string `config:"hmac.type"` - HMACPrefix string `config:"hmac.prefix"` + TLS *tlscommon.ServerConfig `config:"ssl"` + BasicAuth bool `config:"basic_auth"` + Username string `config:"username"` + Password string `config:"password"` + ResponseCode int `config:"response_code" validate:"positive"` + ResponseBody string `config:"response_body"` + ListenAddress string `config:"listen_address"` + ListenPort string `config:"listen_port"` + URL string `config:"url"` + Prefix string `config:"prefix"` + ContentType string `config:"content_type"` + SecretHeader string `config:"secret.header"` + SecretValue string `config:"secret.value"` + HMACHeader string `config:"hmac.header"` + HMACKey string `config:"hmac.key"` + HMACType string `config:"hmac.type"` + HMACPrefix string `config:"hmac.prefix"` + IncludeHeaders []string `config:"include_headers"` + PreserveOriginalEvent bool `config:"preserve_original_event"` } func defaultConfig() config { @@ -78,3 +81,10 @@ func (c *config) Validate() error { return nil } + +func canonicalizeHeaders(headerConf []string) (includeHeaders []string) { + for i := range headerConf { + headerConf[i] = textproto.CanonicalMIMEHeaderKey(headerConf[i]) + } + return headerConf +} diff --git a/x-pack/filebeat/input/http_endpoint/handler.go b/x-pack/filebeat/input/http_endpoint/handler.go index 6d1c0374dc3..f4f0ea3200c 100644 --- a/x-pack/filebeat/input/http_endpoint/handler.go +++ b/x-pack/filebeat/input/http_endpoint/handler.go @@ -5,8 +5,8 @@ package http_endpoint import ( + "bytes" "encoding/json" - "fmt" "io" "net/http" "time" @@ -23,9 +23,11 @@ type httpHandler struct { log *logp.Logger publisher stateless.Publisher - messageField string - responseCode int - responseBody string + messageField string + responseCode int + responseBody string + includeHeaders []string + preserveOriginalEvent bool } var ( @@ -35,14 +37,17 @@ var ( // Triggers if middleware validation returns successful func (h *httpHandler) apiResponse(w http.ResponseWriter, r *http.Request) { - objs, status, err := httpReadJSON(r.Body) + var headers map[string]interface{} + objs, _, status, err := httpReadJSON(r.Body) if err != nil { sendErrorResponse(w, status, err) return } - + if len(h.includeHeaders) > 0 { + headers = getIncludedHeaders(r, h.includeHeaders) + } for _, obj := range objs { - h.publishEvent(obj) + h.publishEvent(obj, headers) } h.sendResponse(w, h.responseCode, h.responseBody) } @@ -53,13 +58,19 @@ func (h *httpHandler) sendResponse(w http.ResponseWriter, status int, message st io.WriteString(w, message) } -func (h *httpHandler) publishEvent(obj common.MapStr) { +func (h *httpHandler) publishEvent(obj common.MapStr, headers common.MapStr) { event := beat.Event{ Timestamp: time.Now().UTC(), Fields: common.MapStr{ h.messageField: obj, }, } + if h.preserveOriginalEvent { + event.PutValue("event.original", obj.String()) + } + if len(headers) > 0 { + event.PutValue("headers", headers) + } h.publisher.Publish(event) } @@ -82,34 +93,94 @@ func sendErrorResponse(w http.ResponseWriter, status int, err error) { e.Encode(common.MapStr{"message": err.Error()}) } -func httpReadJSON(body io.Reader) (objs []common.MapStr, status int, err error) { +func httpReadJSON(body io.Reader) (objs []common.MapStr, rawMessages []json.RawMessage, status int, err error) { if body == http.NoBody { - return nil, http.StatusNotAcceptable, errBodyEmpty + return nil, nil, http.StatusNotAcceptable, errBodyEmpty } + obj, rawMessage, err := decodeJSON(body) + if err != nil { + return nil, nil, http.StatusBadRequest, err + } + return obj, rawMessage, http.StatusOK, err + +} +func decodeJSON(body io.Reader) (objs []common.MapStr, rawMessages []json.RawMessage, err error) { decoder := json.NewDecoder(body) - for idx := 0; ; idx++ { - var obj interface{} - if err := decoder.Decode(&obj); err != nil { + for decoder.More() { + var raw json.RawMessage + if err := decoder.Decode(&raw); err != nil { if err == io.EOF { break } - return nil, http.StatusBadRequest, errors.Wrapf(err, "malformed JSON object at stream position %d", idx) + return nil, nil, errors.Wrapf(err, "malformed JSON object at stream position %d", decoder.InputOffset()) + } + + var obj interface{} + if err := newJSONDecoder(bytes.NewReader(raw)).Decode(&obj); err != nil { + return nil, nil, errors.Wrapf(err, "malformed JSON object at stream position %d", decoder.InputOffset()) } switch v := obj.(type) { case map[string]interface{}: objs = append(objs, v) + rawMessages = append(rawMessages, raw) 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) + nobjs, nrawMessages, err := decodeJSONArray(bytes.NewReader(raw)) + if err != nil { + return nil, nil, errors.Wrapf(err, "recursive error %d", decoder.InputOffset()) } + objs = append(objs, nobjs...) + rawMessages = append(rawMessages, nrawMessages...) default: - return nil, http.StatusBadRequest, errUnsupportedType + return nil, nil, errUnsupportedType + } + } + return objs, rawMessages, nil +} + +func decodeJSONArray(raw *bytes.Reader) (objs []common.MapStr, rawMessages []json.RawMessage, err error) { + dec := newJSONDecoder(raw) + token, err := dec.Token() + if token != json.Delim('[') || err != nil { + return nil, nil, errors.Wrapf(err, "malformed JSON array, not starting with delimiter [ at position: %d", dec.InputOffset()) + } + + for dec.More() { + var raw json.RawMessage + if err := dec.Decode(&raw); err != nil { + if err == io.EOF { + break + } + return nil, nil, errors.Wrapf(err, "malformed JSON object at stream position %d", dec.InputOffset()) + } + + var obj interface{} + if err := newJSONDecoder(bytes.NewReader(raw)).Decode(&obj); err != nil { + return nil, nil, errors.Wrapf(err, "malformed JSON object at stream position %d", dec.InputOffset()) + } + + m, ok := obj.(map[string]interface{}) + if ok { + rawMessages = append(rawMessages, raw) + objs = append(objs, m) + } + } + return +} + +func getIncludedHeaders(r *http.Request, headerConf []string) (includedHeaders common.MapStr) { + includedHeaders = common.MapStr{} + for _, header := range headerConf { + h, found := r.Header[header] + if found { + includedHeaders.Put(header, h) } } - return objs, 0, nil + return includedHeaders +} + +func newJSONDecoder(r io.Reader) *json.Decoder { + dec := json.NewDecoder(r) + dec.UseNumber() + return dec } diff --git a/x-pack/filebeat/input/http_endpoint/handler_test.go b/x-pack/filebeat/input/http_endpoint/handler_test.go index ef1b36d2e73..290265894a6 100644 --- a/x-pack/filebeat/input/http_endpoint/handler_test.go +++ b/x-pack/filebeat/input/http_endpoint/handler_test.go @@ -5,31 +5,36 @@ package http_endpoint import ( + "encoding/json" "net/http" - "reflect" "strings" "testing" + "github.com/stretchr/testify/assert" + "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 string + body string + wantObjs []common.MapStr + wantStatus int + wantErr bool + wantRawMessage []json.RawMessage }{ { - name: "single object", - body: `{"a": 42, "b": "c"}`, - wantObjs: []common.MapStr{{"a": float64(42), "b": "c"}}, + name: "single object", + body: `{"a": "42", "b": "c"}`, + wantObjs: []common.MapStr{{"a": "42", "b": "c"}}, + wantStatus: http.StatusOK, }, { - name: "array accepted", - body: `[{"a":"b"},{"c":"d"}]`, - wantObjs: []common.MapStr{{"a": "b"}, {"c": "d"}}, + name: "array accepted", + body: `[{"a":"b"},{"c":"d"}]`, + wantObjs: []common.MapStr{{"a": "b"}, {"c": "d"}}, + wantStatus: http.StatusOK, }, { name: "not an object not accepted", @@ -38,56 +43,80 @@ func Test_httpReadJSON(t *testing.T) { wantErr: true, }, { - name: "not an object mixed", - body: "[{\"a\":1},\n42,\n{\"a\":2}]", + name: "not an object mixed", + body: `[{a:1}, + 42, + {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 (CRLF)", + body: `{"a":"1"}` + "\r" + `{"a":"2"}`, + wantObjs: []common.MapStr{{"a": "1"}, {"a": "2"}}, + wantStatus: http.StatusOK, }, { - 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 (LF)", + body: `{"a":"1"} + {"a":"2"}`, + wantRawMessage: []json.RawMessage{ + []byte(`{"a":"1"}`), + []byte(`{"a":"2"}`), + }, + wantObjs: []common.MapStr{{"a": "1"}, {"a": "2"}}, + wantStatus: http.StatusOK, }, { - 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 (SP)", + body: `{"a":"2"} {"a":"2"}`, + wantObjs: []common.MapStr{{"a": "2"}, {"a": "2"}}, + wantStatus: http.StatusOK, }, { - name: "sequence of objects accepted (no separator)", - body: "{\"a\":1}{\"a\":2}", - wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + name: "sequence of objects accepted (no separator)", + body: `{"a":"2"}{"a":"2"}`, + wantObjs: []common.MapStr{{"a": "2"}, {"a": "2"}}, + wantStatus: http.StatusOK, }, { - name: "not an object in sequence", - body: "{\"a\":1}\n42\n{\"a\":2}", + name: "not an object in sequence", + body: `{"a":"2"} + 42 + {"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)}}, + name: "array of objects in stream", + body: `{"a":"1"} [{"a":"2"},{"a":"3"}] {"a":"4"}`, + wantRawMessage: []json.RawMessage{ + []byte(`{"a":"1"}`), + []byte(`{"a":"2"}`), + []byte(`{"a":"3"}`), + []byte(`{"a":"4"}`), + }, + wantObjs: []common.MapStr{{"a": "1"}, {"a": "2"}, {"a": "3"}, {"a": "4"}}, + wantStatus: http.StatusOK, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - gotObjs, gotStatus, err := httpReadJSON(strings.NewReader(tt.body)) + gotObjs, rawMessages, 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) { + if !assert.EqualValues(t, tt.wantObjs, gotObjs) { t.Errorf("httpReadJSON() gotObjs = %v, want %v", gotObjs, tt.wantObjs) } if gotStatus != tt.wantStatus { t.Errorf("httpReadJSON() gotStatus = %v, want %v", gotStatus, tt.wantStatus) } + if tt.wantRawMessage != nil { + assert.Equal(t, tt.wantRawMessage, rawMessages) + } + assert.Equal(t, len(gotObjs), len(rawMessages)) }) } } diff --git a/x-pack/filebeat/input/http_endpoint/input.go b/x-pack/filebeat/input/http_endpoint/input.go index b33d0fe137f..e697d5f1441 100644 --- a/x-pack/filebeat/input/http_endpoint/input.go +++ b/x-pack/filebeat/input/http_endpoint/input.go @@ -97,11 +97,13 @@ func (e *httpEndpoint) Run(ctx v2.Context, publisher stateless.Publisher) error } handler := &httpHandler{ - log: log, - publisher: publisher, - messageField: e.config.Prefix, - responseCode: e.config.ResponseCode, - responseBody: e.config.ResponseBody, + log: log, + publisher: publisher, + messageField: e.config.Prefix, + responseCode: e.config.ResponseCode, + responseBody: e.config.ResponseBody, + includeHeaders: canonicalizeHeaders(e.config.IncludeHeaders), + preserveOriginalEvent: e.config.PreserveOriginalEvent, } mux := http.NewServeMux() diff --git a/x-pack/filebeat/tests/system/test_http_endpoint.py b/x-pack/filebeat/tests/system/test_http_endpoint.py index 688b46852e2..a10099c9f0c 100644 --- a/x-pack/filebeat/tests/system/test_http_endpoint.py +++ b/x-pack/filebeat/tests/system/test_http_endpoint.py @@ -5,6 +5,7 @@ import hashlib import os import json +import ast from filebeat import BaseTest from requests.auth import HTTPBasicAuth @@ -27,7 +28,8 @@ def setUp(self): # Hack to make jinja2 have the right paths self.template_env = jinja2.Environment( loader=jinja2.FileSystemLoader([ - os.path.abspath(os.path.join(self.beat_path, "../../filebeat")), + os.path.abspath(os.path.join( + self.beat_path, "../../filebeat")), os.path.abspath(os.path.join(self.beat_path, "../../libbeat")) ]) ) @@ -66,11 +68,13 @@ def test_http_endpoint_request(self): """ self.get_config() filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - headers = {"Content-Type": "application/json", "Accept": "application/json"} + 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 >= 1)) @@ -90,12 +94,14 @@ def test_http_endpoint_request_multiple_documents(self): """ self.get_config() filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + 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"} + 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)) @@ -110,7 +116,8 @@ def test_http_endpoint_request_multiple_documents(self): 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) + assert output[i]["json.{}".format( + self.prefix)] == message.format(i) def test_http_endpoint_request_ndjson(self): """ @@ -122,12 +129,15 @@ def test_http_endpoint_request_ndjson(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + 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"} + 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)) @@ -142,7 +152,8 @@ def test_http_endpoint_request_ndjson(self): 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) + assert output[i]["json.{}".format( + self.prefix)] == message.format(i) def test_http_endpoint_wrong_content_header(self): """ @@ -150,11 +161,13 @@ def test_http_endpoint_wrong_content_header(self): """ self.get_config() filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - headers = {"Content-Type": "application/xml", "Accept": "application/json"} + headers = {"Content-Type": "application/xml", + "Accept": "application/json"} r = requests.post(self.url, headers=headers, data=json.dumps(payload)) filebeat.check_kill_and_wait() @@ -162,7 +175,8 @@ def test_http_endpoint_wrong_content_header(self): print("response:", r.status_code, r.text) assert r.status_code == 415 - assert r.json()['message'] == 'wrong Content-Type header, expecting application/json' + assert r.json()[ + 'message'] == 'wrong Content-Type header, expecting application/json' def test_http_endpoint_missing_auth_value(self): """ @@ -175,7 +189,8 @@ def test_http_endpoint_missing_auth_value(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("username and password required when basicauth is enabled")) + self.wait_until(lambda: self.log_contains( + "username and password required when basicauth is enabled")) filebeat.kill_and_wait() def test_http_endpoint_wrong_auth_value(self): @@ -189,12 +204,15 @@ def test_http_endpoint_wrong_auth_value(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - headers = {"Content-Type": "application/json", "Accept": "application/json"} - r = requests.post(self.url, headers=headers, data=json.dumps(payload), auth=HTTPBasicAuth('testuser', 'qwerty')) + headers = {"Content-Type": "application/json", + "Accept": "application/json"} + r = requests.post(self.url, headers=headers, data=json.dumps( + payload), auth=HTTPBasicAuth('testuser', 'qwerty')) filebeat.check_kill_and_wait() @@ -213,11 +231,13 @@ def test_http_endpoint_wrong_auth_header(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - headers = {"Content-Type": "application/json", "Authorization": "password123"} + headers = {"Content-Type": "application/json", + "Authorization": "password123"} r = requests.post(self.url, headers=headers, data=json.dumps(payload)) filebeat.check_kill_and_wait() @@ -237,11 +257,13 @@ def test_http_endpoint_correct_auth_header(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - headers = {"Content-Type": "application/json", "Authorization": "123password"} + headers = {"Content-Type": "application/json", + "Authorization": "123password"} r = requests.post(self.url, headers=headers, data=json.dumps(payload)) filebeat.check_kill_and_wait() @@ -263,14 +285,17 @@ def test_http_endpoint_valid_hmac(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - h = hmac.new("password123".encode(), json.dumps(payload).encode(), hashlib.sha256) + h = hmac.new("password123".encode(), json.dumps( + payload).encode(), hashlib.sha256) print(h.hexdigest()) - headers = {"Content-Type": "application/json", "X-Hub-Signature-256": "sha256=" + h.hexdigest()} + headers = {"Content-Type": "application/json", + "X-Hub-Signature-256": "sha256=" + h.hexdigest()} r = requests.post(self.url, headers=headers, data=json.dumps(payload)) filebeat.check_kill_and_wait() @@ -292,13 +317,16 @@ def test_http_endpoint_invalid_hmac(self): """ self.get_config(options) filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - h = hmac.new("password321".encode(), json.dumps(payload).encode(), hashlib.sha256) - headers = {"Content-Type": "application/json", "X-Hub-Signature-256": "shad256=" + h.hexdigest()} + h = hmac.new("password321".encode(), json.dumps( + payload).encode(), hashlib.sha256) + headers = {"Content-Type": "application/json", + "X-Hub-Signature-256": "shad256=" + h.hexdigest()} r = requests.post(self.url, headers=headers, data=json.dumps(payload)) filebeat.check_kill_and_wait() @@ -308,15 +336,158 @@ def test_http_endpoint_invalid_hmac(self): assert r.status_code == 401 self.assertRegex(r.json()['message'], 'invalid HMAC signature') + def test_http_endpoint_preserve_original_event(self): + """ + Test http_endpoint input while preserving the original event. + """ + options = """ + preserve_original_event: true +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) + + payload = {self.prefix: "somerandommessage"} + bc = json.dumps(payload, separators=(',', ':')).encode('utf-8') + headers = {"Content-Type": "application/json"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + filebeat.check_kill_and_wait() + output = self.read_output() + + assert r.status_code == 200 + assert output[0]["event.original"].encode("utf-8") == bc + + def test_http_endpoint_include_headers_single_value(self): + """ + Test http_endpoint input while including headers. + """ + options = """ + include_headers: ["TestHeader"] +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) + + message = "somerandommessage" + payload = {self.prefix: message} + headers = {"Content-Type": "application/json", + "TestHeader": "TestHeaderValue"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + filebeat.check_kill_and_wait() + output = self.read_output() + + assert r.status_code == 200 + assert output[0]["headers.Testheader"] == ['TestHeaderValue'] + + def test_http_endpoint_include_headers_empty_value(self): + """ + Test http_endpoint input while including headers that has an emnpty value. + """ + options = """ + include_headers: ["TestHeader"] +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) + + message = "somerandommessage" + payload = {self.prefix: message} + headers = {"Content-Type": "application/json", "TestHeader": ""} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + filebeat.check_kill_and_wait() + output = self.read_output() + + assert r.status_code == 200 + assert output[0]["headers.Testheader"] == [""] + + def test_http_endpoint_include_headers_without_header(self): + """ + Test http_endpoint input while including headers, while the header is not in the request. + """ + options = """ + include_headers: ["TestHeader"] +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) + + message = "somerandommessage" + payload = {self.prefix: message} + headers = {"Content-Type": "application/json"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + filebeat.check_kill_and_wait() + output = self.read_output() + + assert r.status_code == 200 + assert not output[0].get("headers") + + def test_http_endpoint_include_headers_not_canonical_config(self): + """ + Test http_endpoint input while including headers, while the header in config is not canonical. + """ + options = """ + include_headers: ["test-header"] +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) + + message = "somerandommessage" + payload = {self.prefix: message} + headers = {"Content-Type": "application/json", + "Test-Header": "TestHeaderValue"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + filebeat.check_kill_and_wait() + output = self.read_output() + + assert r.status_code == 200 + assert output[0]["headers.Test-Header"] == ["TestHeaderValue"] + + def test_http_endpoint_include_headers_not_canonical_header(self): + """ + Test http_endpoint input while including headers, while the header in request is not canonical. + """ + options = """ + include_headers: ["test-header"] +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) + + message = "somerandommessage" + payload = {self.prefix: message} + headers = {"Content-Type": "application/json", + "test-header": "TestHeaderValue"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + filebeat.check_kill_and_wait() + output = self.read_output() + + assert r.status_code == 200 + assert output[0]["headers.Test-Header"] == ["TestHeaderValue"] + def test_http_endpoint_empty_body(self): """ Test http_endpoint input with empty body. """ self.get_config() filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) - headers = {"Content-Type": "application/json", "Accept": "application/json"} + headers = {"Content-Type": "application/json", + "Accept": "application/json"} r = requests.post(self.url, headers=headers, data="") filebeat.check_kill_and_wait() @@ -333,9 +504,11 @@ def test_http_endpoint_malformed_json(self): self.get_config() filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) payload = '{"message::":: "something"}' - headers = {"Content-Type": "application/json", "Accept": "application/json"} + headers = {"Content-Type": "application/json", + "Accept": "application/json"} r = requests.post(self.url, headers=headers, data=payload) filebeat.check_kill_and_wait() @@ -352,10 +525,12 @@ def test_http_endpoint_get_request(self): self.get_config() filebeat = self.start_beat() - self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + self.wait_until(lambda: self.log_contains( + "Starting HTTP server on {}:{}".format(self.host, self.port))) message = "somerandommessage" payload = {self.prefix: message} - headers = {"Content-Type": "application/json", "Accept": "application/json"} + headers = {"Content-Type": "application/json", + "Accept": "application/json"} r = requests.get(self.url, headers=headers, data=json.dumps(payload)) filebeat.check_kill_and_wait() From afaad351ab52d048f5adf15a264464babf10e705 Mon Sep 17 00:00:00 2001 From: Andrew Stucki Date: Tue, 22 Jun 2021 16:44:11 -0400 Subject: [PATCH 12/20] [Packetbeat] Fix index to raw_index override for agent (#26418) --- packetbeat/publish/publish.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packetbeat/publish/publish.go b/packetbeat/publish/publish.go index d968bbcc0d8..e4e393d8da8 100644 --- a/packetbeat/publish/publish.go +++ b/packetbeat/publish/publish.go @@ -112,7 +112,7 @@ func (p *TransactionPublisher) CreateReporter( clientConfig.PublishMode = beat.DropIfFull } if meta.Index != "" { - clientConfig.Processing.Meta = common.MapStr{"index": meta.Index} + clientConfig.Processing.Meta = common.MapStr{"raw_index": meta.Index} } client, err := p.pipeline.ConnectWith(clientConfig) From 15124f6a9abd9fcb8a655e60fbdaccc9e6bcba67 Mon Sep 17 00:00:00 2001 From: Vignesh Shanmugam Date: Tue, 22 Jun 2021 14:06:01 -0700 Subject: [PATCH 13/20] Heartbeat: update mappings for synthetics metrics (#26248) * Heartbeat: update mappings for synthetics metrics * move experience metrics under duration * update the final mappings * Add duration.us type * address review and add tessts * convert to micros Co-authored-by: Andrew Cholakian Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> --- heartbeat/_meta/fields.common.yml | 87 ++++++++----- heartbeat/docs/fields.asciidoc | 114 +++++++++++++----- heartbeat/include/fields.go | 2 +- x-pack/heartbeat/include/fields.go | 2 +- .../monitors/browser/synthexec/synthtypes.go | 31 ++++- .../browser/synthexec/synthtypes_test.go | 8 +- 6 files changed, 170 insertions(+), 74 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index ae49446e6ab..7a91e9e1ebb 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -158,6 +158,13 @@ type: integer - name: status type: keyword + - name: duration + type: group + description: Duration required to complete the step. + fields: + - name: us + type: integer + description: Duration in microseconds - name: journey type: group fields: @@ -187,7 +194,7 @@ - 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: + fields: - name: hash type: keyword description: Hash that uniquely identifies this image by content. Corresponds to block document id. @@ -196,46 +203,64 @@ fields: - name: experience type: group + description: > + Absolute values of all user experience metrics in the browser + relative to the navigation start event in microseconds 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 + - name: fcp + type: group + description: duration of First contentful paint metric + fields: + - name: us + type: integer + - name: lcp + type: group + description: duration of Largest contentful paint metric + fields: + - name: us + type: integer + - name: dcl + type: group + description: duration of Document content loaded end event + fields: + - name: us + type: integer + - name: load + type: group + description: duration of Load end event + fields: + - name: duration + type: integer + - name: cls + type: integer + description: culumative layout shift score across all frames + - name: relative_trace type: group + description: > + trace event with timing information that are realtive to + journey timings in microseconds fields: - name: name type: keyword + description: name of the trace event - name: type type: text - description: > - could be one of mark or measure event types. + 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 + type: group + description: monotonically increasing trace start time in microseconds + fields: + - name: us + type: long + - name: duration + type: group + description: duration of the trace event in microseconds. + fields: + - name: us + type: integer - name: score type: integer - - name: exists - type: boolean - description: > - flag that indicates if there was any layout shift events - present on the page. + description: weighted score of the layout shift event - key: http title: "HTTP monitor" diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index a9dfe8a1d2e..3e8b6420df4 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -10462,6 +10462,21 @@ type: keyword -- +[float] +=== duration + +Duration required to complete the step. + + +*`synthetics.step.duration.us`*:: ++ +-- +Duration in microseconds + +type: integer + +-- + *`synthetics.journey.name`*:: + @@ -10534,94 +10549,131 @@ type: keyword -- +[float] +=== experience + +Absolute values of all user experience metrics in the browser relative to the navigation start event in microseconds + + -*`synthetics.browser.experience.name`*:: +[float] +=== fcp + +duration of First contentful paint metric + + +*`synthetics.browser.experience.fcp.us`*:: + -- -type: keyword +type: integer -- -*`synthetics.browser.experience.type`*:: +[float] +=== lcp + +duration of Largest contentful paint metric + + +*`synthetics.browser.experience.lcp.us`*:: + -- -denotes the 'mark' event +type: integer +-- -type: text +[float] +=== dcl --- +duration of Document content loaded end event -*`synthetics.browser.experience.start`*:: + +*`synthetics.browser.experience.dcl.us`*:: + -- -offset of time relative to journey start in milliseconds +type: integer +-- -type: long +[float] +=== load --- +duration of Load end event -*`synthetics.browser.user_timing.name`*:: +*`synthetics.browser.experience.load.duration`*:: + -- -type: keyword +type: integer -- -*`synthetics.browser.user_timing.type`*:: +*`synthetics.browser.experience.cls`*:: + -- -could be one of mark or measure event types. - +culumative layout shift score across all frames -type: text +type: integer -- -*`synthetics.browser.user_timing.start`*:: +[float] +=== relative_trace + +trace event with timing information that are realtive to journey timings in microseconds + + + +*`synthetics.browser.relative_trace.name`*:: + -- -offset of time relative to journey start in milliseconds - +name of the trace event -type: long +type: keyword -- -*`synthetics.browser.user_timing.end`*:: +*`synthetics.browser.relative_trace.type`*:: + -- -offset of time relative to journey start in milliseconds +could be one of mark or measure event types - -type: long +type: text -- +[float] +=== start + +monotonically increasing trace start time in microseconds + -*`synthetics.browser.layout_shift.name`*:: +*`synthetics.browser.relative_trace.start.us`*:: + -- -type: keyword +type: long -- -*`synthetics.browser.layout_shift.score`*:: +[float] +=== duration + +duration of the trace event in microseconds. + + +*`synthetics.browser.relative_trace.duration.us`*:: + -- type: integer -- -*`synthetics.browser.layout_shift.exists`*:: +*`synthetics.browser.relative_trace.score`*:: + -- -flag that indicates if there was any layout shift events present on the page. - +weighted score of the layout shift event -type: boolean +type: integer -- diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index a1253b4645b..da35f9b39e2 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 db01484fffa..c8ec656d040 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/synthexec/synthtypes.go b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go index 8b2bd878597..d8ed4b16564 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go @@ -112,17 +112,36 @@ func (se *SynthError) toMap() common.MapStr { } } +type DurationUs struct { + Micros int64 `json:"us"` +} + +func (tu *DurationUs) durationMicros() int64 { + return tu.Micros +} + +func (tu *DurationUs) ToMap() common.MapStr { + if tu == nil { + return nil + } + return common.MapStr{ + "us": tu.durationMicros(), + } +} + type Step struct { - Name string `json:"name"` - Index int `json:"index"` - Status string `json:"status"` + Name string `json:"name"` + Index int `json:"index"` + Status string `json:"status"` + Duration DurationUs `json:"duration"` } func (s *Step) ToMap() common.MapStr { return common.MapStr{ - "name": s.Name, - "index": s.Index, - "status": s.Status, + "name": s.Name, + "index": s.Index, + "status": s.Status, + "duration": s.Duration.ToMap(), } } diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go index daa2a710900..bd052534124 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go @@ -63,7 +63,7 @@ func TestToMap(t *testing.T) { "type": "step/start", "package_version": "1.2.3", "journey": common.MapStr{"name": "MyJourney", "id": "MyJourney"}, - "step": common.MapStr{"name": "MyStep", "status": "success", "index": 42}, + "step": common.MapStr{"name": "MyStep", "status": "success", "index": 42, "duration": common.MapStr{"us": int64(1232131)}}, "root_fields": map[string]interface{}{ "synthetics": map[string]interface{}{ "nested": "v1", @@ -77,7 +77,7 @@ func TestToMap(t *testing.T) { "package_version": "1.2.3", "nested": "v1", "journey": common.MapStr{"name": "MyJourney", "id": "MyJourney"}, - "step": common.MapStr{"name": "MyStep", "status": "success", "index": 42}, + "step": common.MapStr{"name": "MyStep", "status": "success", "index": 42, "duration": common.MapStr{"us": int64(1232131)}}, }, "truly_at_root": "v2", }, @@ -88,7 +88,7 @@ func TestToMap(t *testing.T) { "type": "someType", "package_version": "1.2.3", "journey": common.MapStr{"name": "MyJourney", "id": "MyJourney"}, - "step": common.MapStr{"name": "MyStep", "index": 42, "status": "down"}, + "step": common.MapStr{"name": "MyStep", "index": 42, "status": "down", "duration": common.MapStr{"us": int64(1000)}}, "error": common.MapStr{ "name": "MyErrorName", "message": "MyErrorMessage", @@ -102,7 +102,7 @@ func TestToMap(t *testing.T) { "type": "someType", "package_version": "1.2.3", "journey": common.MapStr{"name": "MyJourney", "id": "MyJourney"}, - "step": common.MapStr{"name": "MyStep", "index": 42, "status": "down"}, + "step": common.MapStr{"name": "MyStep", "index": 42, "status": "down", "duration": common.MapStr{"us": int64(1000)}}, "error": common.MapStr{ "name": "MyErrorName", "message": "MyErrorMessage", From 6e9261f72ebb668388a740429e5a7ece559dbddb Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 22 Jun 2021 17:32:48 -0500 Subject: [PATCH 14/20] [Heartbeat] Skip flaky windows scheduler test (#26422) * [Heartbeat] Skip flaky windows scheduler test Temporarily addresses https://github.com/elastic/beats/issues/26205 by disabling the test on windows. We need a real fix at some point in the future. * Use skip declaration --- heartbeat/scheduler/timerqueue/queue_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/heartbeat/scheduler/timerqueue/queue_test.go b/heartbeat/scheduler/timerqueue/queue_test.go index 431970580ff..ee1794ef59a 100644 --- a/heartbeat/scheduler/timerqueue/queue_test.go +++ b/heartbeat/scheduler/timerqueue/queue_test.go @@ -20,6 +20,7 @@ package timerqueue import ( "context" "math/rand" + "runtime" "sort" "testing" "time" @@ -28,6 +29,9 @@ import ( ) func TestQueueRunsInOrder(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("flaky test on windows: https://github.com/elastic/beats/issues/26205") + } // Bugs can show up only occasionally for i := 0; i < 100; i++ { testQueueRunsInOrderOnce(t) From b7341ae9d3946a25abde1b67a010391ee76dde49 Mon Sep 17 00:00:00 2001 From: Blake Rouse Date: Tue, 22 Jun 2021 19:22:16 -0400 Subject: [PATCH 15/20] [Elastic Agent] Default to port 80 and 443 for Kibana and Fleet Server connections (#25723) * Use 80/443 as default. * Use default 80 443 for kibana connection for agent only. * Add changelog. --- libbeat/common/url.go | 10 ++++++++-- libbeat/kibana/client.go | 7 ++++++- x-pack/elastic-agent/CHANGELOG.next.asciidoc | 1 + x-pack/elastic-agent/pkg/agent/cmd/container.go | 4 ++-- x-pack/elastic-agent/pkg/remote/client.go | 7 ++++--- x-pack/elastic-agent/pkg/remote/client_test.go | 12 ++++++++---- 6 files changed, 29 insertions(+), 12 deletions(-) diff --git a/libbeat/common/url.go b/libbeat/common/url.go index 949c4631edf..abb1fd99036 100644 --- a/libbeat/common/url.go +++ b/libbeat/common/url.go @@ -46,7 +46,10 @@ func MakeURL(defaultScheme string, defaultPath string, rawURL string, defaultPor scheme := addr.Scheme host := addr.Host - port := strconv.Itoa(defaultPort) + port := "" + if defaultPort > 0 { + port = strconv.Itoa(defaultPort) + } if host == "" { host = "localhost" @@ -71,7 +74,10 @@ func MakeURL(defaultScheme string, defaultPath string, rawURL string, defaultPor // reconstruct url addr.Scheme = scheme - addr.Host = host + ":" + port + addr.Host = host + if port != "" { + addr.Host += ":" + port + } return addr.String(), nil } diff --git a/libbeat/kibana/client.go b/libbeat/kibana/client.go index a8509d26636..c2ced9d864d 100644 --- a/libbeat/kibana/client.go +++ b/libbeat/kibana/client.go @@ -91,11 +91,16 @@ func NewKibanaClient(cfg *common.Config) (*Client, error) { // NewClientWithConfig creates and returns a kibana client using the given config func NewClientWithConfig(config *ClientConfig) (*Client, error) { + return NewClientWithConfigDefault(config, 5601) +} + +// NewClientWithConfig creates and returns a kibana client using the given config +func NewClientWithConfigDefault(config *ClientConfig, defaultPort int) (*Client, error) { p := config.Path if config.SpaceID != "" { p = path.Join(p, "s", config.SpaceID) } - kibanaURL, err := common.MakeURL(config.Protocol, p, config.Host, 5601) + kibanaURL, err := common.MakeURL(config.Protocol, p, config.Host, defaultPort) if err != nil { return nil, fmt.Errorf("invalid Kibana host: %v", err) } diff --git a/x-pack/elastic-agent/CHANGELOG.next.asciidoc b/x-pack/elastic-agent/CHANGELOG.next.asciidoc index b1f7ecdce12..e1ccd6c4c62 100644 --- a/x-pack/elastic-agent/CHANGELOG.next.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.next.asciidoc @@ -11,6 +11,7 @@ - Read Fleet connection information from `fleet.*` instead of `fleet.kibana.*`. {pull}24713[24713] - Beats build for 32Bit Windows or Linux system will refuse to run on a 64bit system. {pull}25186[25186] - Remove the `--kibana-url` from `install` and `enroll` command. {pull}25529[25529] +- Default to port 80 and 443 for Kibana and Fleet Server connections. {pull}25723[25723] ==== Bugfixes - Fix rename *ConfigChange to *PolicyChange to align on changes in the UI. {pull}20779[20779] diff --git a/x-pack/elastic-agent/pkg/agent/cmd/container.go b/x-pack/elastic-agent/pkg/agent/cmd/container.go index 26a14b87fd8..8f7b75578b3 100644 --- a/x-pack/elastic-agent/pkg/agent/cmd/container.go +++ b/x-pack/elastic-agent/pkg/agent/cmd/container.go @@ -457,14 +457,14 @@ func kibanaClient(cfg kibanaConfig, headers map[string]string) (*kibana.Client, } } - return kibana.NewClientWithConfig(&kibana.ClientConfig{ + return kibana.NewClientWithConfigDefault(&kibana.ClientConfig{ Host: cfg.Fleet.Host, Username: cfg.Fleet.Username, Password: cfg.Fleet.Password, IgnoreVersion: true, TLS: tls, Headers: headers, - }) + }, 0) } func findPolicy(cfg setupConfig, policies []kibanaPolicy) (*kibanaPolicy, error) { diff --git a/x-pack/elastic-agent/pkg/remote/client.go b/x-pack/elastic-agent/pkg/remote/client.go index e12512d9ee0..281b3798944 100644 --- a/x-pack/elastic-agent/pkg/remote/client.go +++ b/x-pack/elastic-agent/pkg/remote/client.go @@ -9,6 +9,7 @@ import ( "io" "net/http" "net/url" + "regexp" "strings" "sync" "time" @@ -28,6 +29,8 @@ const ( retryOnBadConnTimeout = 5 * time.Minute ) +var hasScheme = regexp.MustCompile(`^([a-z][a-z0-9+\-.]*)://`) + type requestFunc func(string, string, url.Values, io.Reader) (*http.Request, error) type wrapperFunc func(rt http.RoundTripper) (http.RoundTripper, error) @@ -107,8 +110,6 @@ func NewWithConfig(log *logger.Logger, cfg Config, wrapper wrapperFunc) (*Client p = p + "/" } - usedDefaultPort := defaultPort - hosts := cfg.GetHosts() clients := make([]*requestClient, len(hosts)) for i, host := range cfg.GetHosts() { @@ -135,7 +136,7 @@ func NewWithConfig(log *logger.Logger, cfg Config, wrapper wrapperFunc) (*Client Timeout: cfg.Timeout, } - url, err := common.MakeURL(string(cfg.Protocol), p, host, usedDefaultPort) + url, err := common.MakeURL(string(cfg.Protocol), p, host, 0) if err != nil { return nil, errors.Wrap(err, "invalid fleet-server endpoint") } diff --git a/x-pack/elastic-agent/pkg/remote/client_test.go b/x-pack/elastic-agent/pkg/remote/client_test.go index ec304573f41..f05341d5e36 100644 --- a/x-pack/elastic-agent/pkg/remote/client_test.go +++ b/x-pack/elastic-agent/pkg/remote/client_test.go @@ -44,10 +44,10 @@ func TestPortDefaults(t *testing.T) { ExpectedPort int ExpectedScheme string }{ - {"no scheme uri", "test.url", defaultPort, "http"}, - {"default port", "http://test.url", defaultPort, "http"}, + {"no scheme uri", "test.url", 0, "http"}, + {"default port", "http://test.url", 0, "http"}, {"specified port", "http://test.url:123", 123, "http"}, - {"default https port", "https://test.url", defaultPort, "https"}, + {"default https port", "https://test.url", 0, "https"}, {"specified https port", "https://test.url:123", 123, "https"}, } for _, tc := range testCases { @@ -61,7 +61,11 @@ func TestPortDefaults(t *testing.T) { r, err := c.nextRequester().request("GET", "/", nil, strings.NewReader("")) require.NoError(t, err) - assert.True(t, strings.HasSuffix(r.Host, fmt.Sprintf(":%d", tc.ExpectedPort))) + if tc.ExpectedPort > 0 { + assert.True(t, strings.HasSuffix(r.Host, fmt.Sprintf(":%d", tc.ExpectedPort))) + } else { + assert.False(t, strings.HasSuffix(r.Host, fmt.Sprintf(":%d", tc.ExpectedPort))) + } assert.Equal(t, tc.ExpectedScheme, r.URL.Scheme) }) } From 35c86083ecd8dc46ec9d65061dfc6105b050785f Mon Sep 17 00:00:00 2001 From: Victor Martinez Date: Wed, 23 Jun 2021 10:30:39 +0100 Subject: [PATCH 16/20] Automate the go version update (#26343) --- .ci/bump-go-release-version.sh | 40 ++++++++++++++++++++++++++++++++++ .gitignore | 4 ++-- .mergify.yml | 24 +++++++++++++++----- 3 files changed, 61 insertions(+), 7 deletions(-) create mode 100755 .ci/bump-go-release-version.sh diff --git a/.ci/bump-go-release-version.sh b/.ci/bump-go-release-version.sh new file mode 100755 index 00000000000..3a3244f2343 --- /dev/null +++ b/.ci/bump-go-release-version.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +# +# Given the Golang release version this script will bump the version. +# +# This script is executed by the automation we are putting in place +# and it requires the git add/commit commands. +# +# Parameters: +# $1 -> the Golang release version to be bumped. Mandatory. +# +set -euo pipefail +MSG="parameter missing." +GO_RELEASE_VERSION=${1:?$MSG} + +OS=$(uname -s| tr '[:upper:]' '[:lower:]') + +if [ "${OS}" == "darwin" ] ; then + SED="sed -i .bck" +else + SED="sed -i" +fi + +echo "Update go version ${GO_RELEASE_VERSION}" +echo "${GO_RELEASE_VERSION}" > .go-version +git add .go-version + +find . -maxdepth 3 -name Dockerfile -print0 | + while IFS= read -r -d '' line; do + ${SED} -E -e "s#(FROM golang):[0-9]+\.[0-9]+\.[0-9]+#\1:${GO_RELEASE_VERSION}#g" "$line" + ${SED} -E -e "s#(ARG GO_VERSION)=[0-9]+\.[0-9]+\.[0-9]+#\1=${GO_RELEASE_VERSION}#g" "$line" + git add "${line}" + done + +${SED} -E -e "s#(:go-version:) [0-9]+\.[0-9]+\.[0-9]+#\1 ${GO_RELEASE_VERSION}#g" libbeat/docs/version.asciidoc +git add libbeat/docs/version.asciidoc + +git diff --staged --quiet || git commit -m "[Automation] Update go release version to ${GO_RELEASE_VERSION}" +git --no-pager log -1 + +echo "You can now push and create a Pull Request" diff --git a/.gitignore b/.gitignore index 1f7b9ad9f11..3f7ae5c0ba4 100644 --- a/.gitignore +++ b/.gitignore @@ -51,5 +51,5 @@ x-pack/elastic-agent/pkg/agent/operation/tests/scripts/serviceable-1.0-darwin-x8 *.terraform *.tfstate* -# Files generated with the bump elastic stack version automation -testing/environments/*.bck +# Files generated with the bump version automations +*.bck diff --git a/.mergify.yml b/.mergify.yml index bff284a030f..a2a2c3ebbe5 100644 --- a/.mergify.yml +++ b/.mergify.yml @@ -84,11 +84,25 @@ pull_request_rules: merge: method: squash strict: smart+fasttrack - - name: delete upstream branch after merging changes on testing/environments/snapshot* + - name: delete upstream branch after merging changes on testing/environments/snapshot* or it's closed conditions: - - merged - - label=automation - - head~=^update-stack-version - - files~=^testing/environments/snapshot.*\.yml$ + - or: + - merged + - closed + - and: + - label=automation + - head~=^update-stack-version + - files~=^testing/environments/snapshot.*\.yml$ + actions: + delete_head_branch: + - name: delete upstream branch after merging changes on .go-version or it's closed + conditions: + - or: + - merged + - closed + - and: + - label=automation + - head~=^update-go-version + - files~=^.go-version$ actions: delete_head_branch: From 9de1352e7e53d899284d4573931de119c44c4ea9 Mon Sep 17 00:00:00 2001 From: Pier-Hugues Pellerin Date: Wed, 23 Jun 2021 08:51:14 -0400 Subject: [PATCH 17/20] Add support for Logstash as a valid Agent destination (#24305) * Add support for Logstash as a valid Agent destination This PR fixes an issue to use an logstash output as a monitoring destination, this correctly uses the type defined in the output to generate the appropriate output configuration for the monitoring processes. --- x-pack/elastic-agent/CHANGELOG.next.asciidoc | 1 + .../emitter/modifiers/monitoring_decorator.go | 23 ++- .../modifiers/monitoring_decorator_test.go | 155 +++++++++++++----- .../pkg/agent/operation/monitoring.go | 58 +++++-- .../pkg/agent/operation/monitoring_test.go | 11 +- .../elastic-agent/pkg/agent/transpiler/ast.go | 15 ++ .../pkg/agent/transpiler/ast_test.go | 44 +++++ 7 files changed, 239 insertions(+), 68 deletions(-) diff --git a/x-pack/elastic-agent/CHANGELOG.next.asciidoc b/x-pack/elastic-agent/CHANGELOG.next.asciidoc index e1ccd6c4c62..d54b3e273a9 100644 --- a/x-pack/elastic-agent/CHANGELOG.next.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.next.asciidoc @@ -71,6 +71,7 @@ - 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] +- Fix add support for Logstash output. {pull}24305[24305] ==== New features diff --git a/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator.go b/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator.go index 5c1d2d037fd..8c3eb1c7d43 100644 --- a/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator.go +++ b/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator.go @@ -55,19 +55,18 @@ func InjectMonitoring(agentInfo *info.AgentInfo, outputGroup string, rootAst *tr } // get monitoring output name to be used - monitoringOutputName := defaultOutputName - useOutputNode, found := transpiler.Lookup(rootAst, monitoringUseOutputKey) - if found { - monitoringOutputNameKey, ok := useOutputNode.Value().(*transpiler.StrVal) - if !ok { - return programsToRun, nil - } - - monitoringOutputName = monitoringOutputNameKey.String() + monitoringOutputName, found := transpiler.LookupString(rootAst, monitoringUseOutputKey) + if !found { + monitoringOutputName = defaultOutputName + } + + typeValue, found := transpiler.LookupString(rootAst, fmt.Sprintf("%s.%s.type", outputsKey, monitoringOutputName)) + if !found { + typeValue = elasticsearchKey } ast := rootAst.Clone() - if err := getMonitoringRule(monitoringOutputName).Apply(agentInfo, ast); err != nil { + if err := getMonitoringRule(monitoringOutputName, typeValue).Apply(agentInfo, ast); err != nil { return programsToRun, err } @@ -95,11 +94,11 @@ func InjectMonitoring(agentInfo *info.AgentInfo, outputGroup string, rootAst *tr return append(programsToRun, monitoringProgram), nil } -func getMonitoringRule(outputName string) *transpiler.RuleList { +func getMonitoringRule(outputName string, t string) *transpiler.RuleList { monitoringOutputSelector := fmt.Sprintf(monitoringOutputFormatKey, outputName) return transpiler.NewRuleList( transpiler.Copy(monitoringOutputSelector, outputKey), - transpiler.Rename(fmt.Sprintf("%s.%s", outputsKey, outputName), elasticsearchKey), + transpiler.Rename(fmt.Sprintf("%s.%s", outputsKey, outputName), t), transpiler.Filter(monitoringKey, programsKey, outputKey), ) } diff --git a/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator_test.go b/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator_test.go index afb15edac80..45b8ebab434 100644 --- a/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator_test.go +++ b/x-pack/elastic-agent/pkg/agent/application/pipeline/emitter/modifiers/monitoring_decorator_test.go @@ -171,6 +171,85 @@ GROUPLOOP: } } +func TestMonitoringToLogstashInjection(t *testing.T) { + agentInfo, err := info.NewAgentInfo(true) + if err != nil { + t.Fatal(err) + } + ast, err := transpiler.NewAST(inputConfigLS) + if err != nil { + t.Fatal(err) + } + + programsToRun, err := program.Programs(agentInfo, ast) + if err != nil { + t.Fatal(err) + } + + if len(programsToRun) != 1 { + t.Fatal(fmt.Errorf("programsToRun expected to have %d entries", 1)) + } + +GROUPLOOP: + for group, ptr := range programsToRun { + programsCount := len(ptr) + newPtr, err := InjectMonitoring(agentInfo, group, ast, ptr) + if err != nil { + t.Error(err) + continue GROUPLOOP + } + + if programsCount+1 != len(newPtr) { + t.Errorf("incorrect programs to run count, expected: %d, got %d", programsCount+1, len(newPtr)) + continue GROUPLOOP + } + + for _, p := range newPtr { + if p.Spec.Name != MonitoringName { + continue + } + + cm, err := p.Config.Map() + if err != nil { + t.Error(err) + continue GROUPLOOP + } + + outputCfg, found := cm[outputKey] + if !found { + t.Errorf("output not found for '%s'", group) + continue GROUPLOOP + } + + outputMap, ok := outputCfg.(map[string]interface{}) + if !ok { + t.Errorf("output is not a map for '%s'", group) + continue GROUPLOOP + } + + esCfg, found := outputMap["logstash"] + if !found { + t.Errorf("logstash output not found for '%s' %v", group, outputMap) + continue GROUPLOOP + } + + esMap, ok := esCfg.(map[string]interface{}) + if !ok { + t.Errorf("output.logstash is not a map for '%s'", group) + continue GROUPLOOP + } + + if uname, found := esMap["hosts"]; !found { + t.Errorf("output.logstash.hosts output not found for '%s'", group) + continue GROUPLOOP + } else if uname != "192.168.1.2" { + t.Errorf("output.logstash.hosts has incorrect value expected '%s', got '%s for %s", "monitoring-uname", uname, group) + continue GROUPLOOP + } + } + } +} + func TestMonitoringInjectionDisabled(t *testing.T) { agentInfo, err := info.NewAgentInfo(true) if err != nil { @@ -613,42 +692,40 @@ var inputChange2 = map[string]interface{}{ }, } -// const inputConfig = `outputs: -// default: -// index_name: general -// pass: xxx -// type: es -// url: xxxxx -// username: xxx -// infosec1: -// pass: xxx -// spool: -// file: "${path.data}/spool.dat" -// type: es -// url: xxxxx -// username: xxx -// streams: -// - -// output: -// override: -// index_name: my_service_logs -// ingest_pipeline: process_logs -// path: /xxxx -// processors: -// - -// dissect: -// tokenizer: "---" -// type: log -// - -// output: -// index_name: mysql_access_logs -// path: /xxxx -// type: log -// - -// output: -// index_name: mysql_metrics -// use_output: infosec1 -// pass: yyy -// type: metrics/system -// username: xxxx -// ` +var inputConfigLS = map[string]interface{}{ + "agent.monitoring": map[string]interface{}{ + "enabled": true, + "logs": true, + "metrics": true, + "use_output": "monitoring", + }, + "outputs": map[string]interface{}{ + "default": map[string]interface{}{ + "index_name": "general", + "pass": "xxx", + "type": "elasticsearch", + "url": "xxxxx", + "username": "xxx", + }, + "monitoring": map[string]interface{}{ + "type": "logstash", + "hosts": "192.168.1.2", + "ssl.certificate_authorities": []string{"/etc/pki.key"}, + }, + }, + "inputs": []map[string]interface{}{ + { + "type": "log", + "streams": []map[string]interface{}{ + {"paths": "/xxxx"}, + }, + "processors": []interface{}{ + map[string]interface{}{ + "dissect": map[string]interface{}{ + "tokenizer": "---", + }, + }, + }, + }, + }, +} diff --git a/x-pack/elastic-agent/pkg/agent/operation/monitoring.go b/x-pack/elastic-agent/pkg/agent/operation/monitoring.go index d7c81d9a3a9..45b7263cf73 100644 --- a/x-pack/elastic-agent/pkg/agent/operation/monitoring.go +++ b/x-pack/elastic-agent/pkg/agent/operation/monitoring.go @@ -69,7 +69,7 @@ func (o *Operator) handleStartSidecar(s configrequest.Step) (result error) { } func (o *Operator) handleStopSidecar(s configrequest.Step) (result error) { - for _, step := range o.generateMonitoringSteps(s.Version, nil) { + for _, step := range o.generateMonitoringSteps(s.Version, "", nil) { p, _, err := getProgramFromStepWithTags(step, o.config.DownloadConfig, monitoringTags()) if err != nil { return errors.New(err, @@ -115,16 +115,49 @@ func (o *Operator) getMonitoringSteps(step configrequest.Step) []configrequest.S return nil } - output, found := outputMap["elasticsearch"] - if !found { - o.logger.Error("operator.getMonitoringSteps: monitoring is missing an elasticsearch output configuration configuration for sidecar of type: %s", step.ProgramSpec.Cmd) + if len(outputMap) == 0 { + o.logger.Errorf("operator.getMonitoringSteps: monitoring is missing an output configuration for sidecar of type: %s", step.ProgramSpec.Cmd) + return nil + } + + // Guards against parser issues upstream, this should not be possible but + // since we are folding all the child options as a map we should make sure we have + //a unique output. + if len(outputMap) > 1 { + o.logger.Errorf("operator.getMonitoringSteps: monitoring has too many outputs configuration for sidecar of type: %s", step.ProgramSpec.Cmd) + return nil + } + + // Aggregate output configuration independently of the received output key. + output := make(map[string]interface{}) + + for _, v := range outputMap { + child, ok := v.(map[string]interface{}) + if !ok { + o.logger.Error("operator.getMonitoringSteps: monitoring config is not a map") + return nil + } + for c, j := range child { + output[c] = j + } + } + + t, ok := output["type"] + if !ok { + o.logger.Errorf("operator.getMonitoringSteps: unknown monitoring output for sidecar of type: %s", step.ProgramSpec.Cmd) return nil } - return o.generateMonitoringSteps(step.Version, output) + outputType, ok := t.(string) + if !ok { + o.logger.Errorf("operator.getMonitoringSteps: unexpected monitoring output type: %+v for sidecar of type: %s", t, step.ProgramSpec.Cmd) + return nil + } + + return o.generateMonitoringSteps(step.Version, outputType, output) } -func (o *Operator) generateMonitoringSteps(version string, output interface{}) []configrequest.Step { +func (o *Operator) generateMonitoringSteps(version, outputType string, output interface{}) []configrequest.Step { var steps []configrequest.Step watchLogs := o.monitor.WatchLogs() watchMetrics := o.monitor.WatchMetrics() @@ -132,7 +165,7 @@ func (o *Operator) generateMonitoringSteps(version string, output interface{}) [ // generate only when monitoring is running (for config refresh) or // state changes (turning on/off) if watchLogs != o.isMonitoringLogs() || watchLogs { - fbConfig, any := o.getMonitoringFilebeatConfig(output) + fbConfig, any := o.getMonitoringFilebeatConfig(outputType, output) stepID := configrequest.StepRun if !watchLogs || !any { stepID = configrequest.StepRemove @@ -149,7 +182,7 @@ func (o *Operator) generateMonitoringSteps(version string, output interface{}) [ steps = append(steps, filebeatStep) } if watchMetrics != o.isMonitoringMetrics() || watchMetrics { - mbConfig, any := o.getMonitoringMetricbeatConfig(output) + mbConfig, any := o.getMonitoringMetricbeatConfig(outputType, output) stepID := configrequest.StepRun if !watchMetrics || !any { stepID = configrequest.StepRemove @@ -182,7 +215,7 @@ func loadSpecFromSupported(processName string) program.Spec { } } -func (o *Operator) getMonitoringFilebeatConfig(output interface{}) (map[string]interface{}, bool) { +func (o *Operator) getMonitoringFilebeatConfig(outputType string, output interface{}) (map[string]interface{}, bool) { inputs := []interface{}{ map[string]interface{}{ "type": "filestream", @@ -297,12 +330,13 @@ func (o *Operator) getMonitoringFilebeatConfig(output interface{}) (map[string]i }) } } + result := map[string]interface{}{ "filebeat": map[string]interface{}{ "inputs": inputs, }, "output": map[string]interface{}{ - "elasticsearch": output, + outputType: output, }, } @@ -311,7 +345,7 @@ func (o *Operator) getMonitoringFilebeatConfig(output interface{}) (map[string]i return result, true } -func (o *Operator) getMonitoringMetricbeatConfig(output interface{}) (map[string]interface{}, bool) { +func (o *Operator) getMonitoringMetricbeatConfig(outputType string, output interface{}) (map[string]interface{}, bool) { hosts := o.getMetricbeatEndpoints() if len(hosts) == 0 { return nil, false @@ -526,7 +560,7 @@ func (o *Operator) getMonitoringMetricbeatConfig(output interface{}) (map[string "modules": modules, }, "output": map[string]interface{}{ - "elasticsearch": output, + outputType: output, }, } diff --git a/x-pack/elastic-agent/pkg/agent/operation/monitoring_test.go b/x-pack/elastic-agent/pkg/agent/operation/monitoring_test.go index cbf9edf3266..136c9e485b1 100644 --- a/x-pack/elastic-agent/pkg/agent/operation/monitoring_test.go +++ b/x-pack/elastic-agent/pkg/agent/operation/monitoring_test.go @@ -31,6 +31,7 @@ import ( func TestGenerateSteps(t *testing.T) { const sampleOutput = "sample-output" + const outputType = "logstash" type testCase struct { Name string @@ -51,7 +52,7 @@ func TestGenerateSteps(t *testing.T) { t.Run(tc.Name, func(t *testing.T) { m := &testMonitor{monitorLogs: tc.Config.MonitorLogs, monitorMetrics: tc.Config.MonitorMetrics} operator := getMonitorableTestOperator(t, "tests/scripts", m, tc.Config) - steps := operator.generateMonitoringSteps("8.0", sampleOutput) + steps := operator.generateMonitoringSteps("8.0", outputType, sampleOutput) if actualSteps := len(steps); actualSteps != tc.ExpectedSteps { t.Fatalf("invalid number of steps, expected %v, got %v", tc.ExpectedSteps, actualSteps) } @@ -61,13 +62,13 @@ func TestGenerateSteps(t *testing.T) { // Filebeat step check if s.ProgramSpec.Cmd == "filebeat" { fbFound = true - checkStep(t, "filebeat", sampleOutput, s) + checkStep(t, "filebeat", outputType, sampleOutput, s) } // Metricbeat step check if s.ProgramSpec.Cmd == "metricbeat" { mbFound = true - checkStep(t, "metricbeat", sampleOutput, s) + checkStep(t, "metricbeat", outputType, sampleOutput, s) } } @@ -82,7 +83,7 @@ func TestGenerateSteps(t *testing.T) { } } -func checkStep(t *testing.T, stepName string, expectedOutput interface{}, s configrequest.Step) { +func checkStep(t *testing.T, stepName string, outputType string, expectedOutput interface{}, s configrequest.Step) { if meta := s.Meta[configrequest.MetaConfigKey]; meta != nil { mapstr, ok := meta.(map[string]interface{}) if !ok { @@ -94,7 +95,7 @@ func checkStep(t *testing.T, stepName string, expectedOutput interface{}, s conf t.Fatalf("output not found for %s step", stepName) } - if actualOutput := esOut["elasticsearch"]; actualOutput != expectedOutput { + if actualOutput := esOut[outputType]; actualOutput != expectedOutput { t.Fatalf("output for %s step does not match. expected: %v, got %v", stepName, expectedOutput, actualOutput) } } diff --git a/x-pack/elastic-agent/pkg/agent/transpiler/ast.go b/x-pack/elastic-agent/pkg/agent/transpiler/ast.go index cc61efd63ea..100d8a462a0 100644 --- a/x-pack/elastic-agent/pkg/agent/transpiler/ast.go +++ b/x-pack/elastic-agent/pkg/agent/transpiler/ast.go @@ -1023,6 +1023,21 @@ func Lookup(a *AST, selector Selector) (Node, bool) { return current, true } +// LookupString accepts an AST and a selector and return the matching node at that position as a string. +func LookupString(a *AST, selector Selector) (string, bool) { + n, ok := Lookup(a, selector) + if !ok { + return "", false + } + + v, ok := n.Value().(*StrVal) + if !ok { + return "", false + } + + return v.String(), true +} + // Insert inserts a node into an existing AST, will return and error if the target position cannot // accept a new node. func Insert(a *AST, node Node, to Selector) error { diff --git a/x-pack/elastic-agent/pkg/agent/transpiler/ast_test.go b/x-pack/elastic-agent/pkg/agent/transpiler/ast_test.go index b48d15a112a..e1b22c390ed 100644 --- a/x-pack/elastic-agent/pkg/agent/transpiler/ast_test.go +++ b/x-pack/elastic-agent/pkg/agent/transpiler/ast_test.go @@ -1793,6 +1793,50 @@ func TestHash(t *testing.T) { } } +func TestLookupString(t *testing.T) { + t.Run("when the selector exist with a string value", func(t *testing.T) { + a := &AST{ + root: &Dict{ + value: []Node{ + &Key{name: "inputs", value: &StrVal{value: "/var/log/log1"}}, + }, + }, + } + + s, ok := LookupString(a, "inputs") + assert.Equal(t, "/var/log/log1", s) + assert.True(t, ok) + }) + + t.Run("when the selector doesn't exist", func(t *testing.T) { + a := &AST{ + root: &Dict{ + value: []Node{ + &Key{name: "Weee!", value: &StrVal{value: "/var/log/log1"}}, + }, + }, + } + + s, ok := LookupString(a, "inputs") + assert.Equal(t, "", s) + assert.False(t, ok) + }) + + t.Run("when the node is not a StrVal will fail", func(t *testing.T) { + a := &AST{ + root: &Dict{ + value: []Node{ + &Key{name: "inputs", value: &FloatVal{value: 4.2}}, + }, + }, + } + + s, ok := LookupString(a, "inputs") + assert.Equal(t, "", s) + assert.False(t, ok) + }) +} + func mustMakeVars(mapping map[string]interface{}) *Vars { v, err := NewVars(mapping, nil) if err != nil { From ea84a3b215795aaad846468cd2a7d4fec92f8c97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Manuel=20de=20la=20Pe=C3=B1a?= Date: Wed, 23 Jun 2021 16:50:40 +0200 Subject: [PATCH 18/20] chore: pass BEAT_VERSION when running E2E tests (#26291) --- .ci/packaging.groovy | 2 ++ Jenkinsfile | 1 + 2 files changed, 3 insertions(+) diff --git a/.ci/packaging.groovy b/.ci/packaging.groovy index 6b41838ce45..d0d7c00c1b5 100644 --- a/.ci/packaging.groovy +++ b/.ci/packaging.groovy @@ -425,11 +425,13 @@ def triggerE2ETests(String suite) { def branchName = isPR() ? "${env.CHANGE_TARGET}" : "${env.JOB_BASE_NAME}" def e2eTestsPipeline = "e2e-tests/e2e-testing-mbp/${branchName}" + def beatVersion = "${env.BEAT_VERSION}-SNAPSHOT" def parameters = [ booleanParam(name: 'forceSkipGitChecks', value: true), booleanParam(name: 'forceSkipPresubmit', value: true), booleanParam(name: 'notifyOnGreenBuilds', value: !isPR()), + booleanParam(name: 'BEAT_VERSION', value: beatVersion), booleanParam(name: 'BEATS_USE_CI_SNAPSHOTS', value: true), string(name: 'runTestsSuites', value: suite), string(name: 'GITHUB_CHECK_NAME', value: env.GITHUB_CHECK_E2E_TESTS_NAME), diff --git a/Jenkinsfile b/Jenkinsfile index 5236cd129c0..527bcbecb55 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -520,6 +520,7 @@ def e2e(Map args = [:]) { def goVersionForE2E = readFile('.go-version').trim() withEnv(["GO_VERSION=${goVersionForE2E}", "BEATS_LOCAL_PATH=${env.WORKSPACE}/${env.BASE_DIR}", + "BEAT_VERSION=${env.VERSION}-SNAPSHOT", "LOG_LEVEL=TRACE"]) { def status = 0 filebeat(output: dockerLogFile){ From bb4399ea8572358c22f12d2458f2b5300868bc53 Mon Sep 17 00:00:00 2001 From: kaiyan-sheng Date: Wed, 23 Jun 2021 22:53:45 +0800 Subject: [PATCH 19/20] disable metricbeat logstash test_node_stats (#26436) --- metricbeat/module/logstash/test_logstash.py | 1 + 1 file changed, 1 insertion(+) diff --git a/metricbeat/module/logstash/test_logstash.py b/metricbeat/module/logstash/test_logstash.py index 533213409be..994983c9d85 100644 --- a/metricbeat/module/logstash/test_logstash.py +++ b/metricbeat/module/logstash/test_logstash.py @@ -25,6 +25,7 @@ def test_node(self): self.check_metricset("logstash", "node", self.get_hosts(), self.FIELDS + ["process"]) @unittest.skipUnless(metricbeat.INTEGRATION_TESTS, "integration test") + @unittest.skip("flaky test: https://github.com/elastic/beats/issues/26432") def test_node_stats(self): """ logstash node_stats metricset test From a300f1bcbccce1c54cfb41c08d5e88cab18c87c0 Mon Sep 17 00:00:00 2001 From: Alex Resnick Date: Wed, 23 Jun 2021 10:18:46 -0500 Subject: [PATCH 20/20] [Filebeat] Update HA Proxy log grok patterns (#25835) * #25827: Update HA Proxy log grok patterns * update changelog * add more sample data --- CHANGELOG.next.asciidoc | 2 +- .../module/haproxy/log/ingest/pipeline.yml | 23 +- filebeat/module/haproxy/log/test/haproxy.log | 9 + .../log/test/haproxy.log-expected.json | 434 ++++++++++++++++++ 4 files changed, 462 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index d5b2edf2e3d..f9612a4a427 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -824,7 +824,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add `log.flags` to events created by the `aws-s3` input. {pull}26267[26267] - Add `include_s3_metadata` config option to the `aws-s3` input for including object metadata in events. {pull}26267[26267] - RFC 5424 and UNIX socket support in the Syslog input are now GA {pull}26293[26293] - +- Update grok patterns for HA Proxy module {issue}25827[25827] {pull}25835[25835] *Heartbeat* diff --git a/filebeat/module/haproxy/log/ingest/pipeline.yml b/filebeat/module/haproxy/log/ingest/pipeline.yml index f491556bd81..2813beaa155 100644 --- a/filebeat/module/haproxy/log/ingest/pipeline.yml +++ b/filebeat/module/haproxy/log/ingest/pipeline.yml @@ -8,21 +8,21 @@ processors: field: message patterns: - '%{HAPROXY_DATE:haproxy.request_date} %{IPORHOST:haproxy.source} %{PROG:process.name}(?:\[%{POSINT:process.pid:long}\])?: - %{GREEDYDATA} %{IPORHOST:source.address}:%{POSINT:source.port:long} %{WORD} + %{GREEDYDATA} (%{IPORHOST:source.address}|-):%{POSINT:source.port:long} %{WORD} %{IPORHOST:destination.ip}:%{POSINT:destination.port:long} \(%{WORD:haproxy.frontend_name}/%{WORD:haproxy.mode}\)' - - '(%{NOTSPACE:process.name}\[%{NUMBER:process.pid:long}\]: )?%{IP:source.address}:%{NUMBER:source.port:long} + - '(%{NOTSPACE:process.name}\[%{NUMBER:process.pid:long}\]: )?(%{IP:source.address}|-):%{NUMBER:source.port:long} \[%{NOTSPACE:haproxy.request_date}\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} - %{NUMBER:haproxy.http.request.time_wait_ms:long}/%{NUMBER:haproxy.total_waiting_time_ms:long}/%{NUMBER:haproxy.connection_wait_time_ms:long}/%{NUMBER:haproxy.http.request.time_wait_without_data_ms:long}/%{NUMBER:temp.duration:long} + (%{IPORHOST:destination.address} )?%{NUMBER:haproxy.http.request.time_wait_ms:long}/%{NUMBER:haproxy.total_waiting_time_ms:long}/%{NUMBER:haproxy.connection_wait_time_ms:long}/%{NUMBER:haproxy.http.request.time_wait_without_data_ms:long}/%{NUMBER:temp.duration:long} %{NUMBER:http.response.status_code:long} %{NUMBER:haproxy.bytes_read:long} %{NOTSPACE:haproxy.http.request.captured_cookie} %{NOTSPACE:haproxy.http.response.captured_cookie} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:long}/%{NUMBER:haproxy.connections.frontend:long}/%{NUMBER:haproxy.connections.backend:long}/%{NUMBER:haproxy.connections.server:long}/%{NUMBER:haproxy.connections.retries:long} %{NUMBER:haproxy.server_queue:long}/%{NUMBER:haproxy.backend_queue:long} (\{%{DATA:haproxy.http.request.captured_headers}\} \{%{DATA:haproxy.http.response.captured_headers}\} |\{%{DATA}\} )?"%{GREEDYDATA:haproxy.http.request.raw_request_line}"' - - '(%{NOTSPACE:process.name}\[%{NUMBER:process.pid:long}\]: )?%{IP:source.address}:%{NUMBER:source.port:long} + - '(%{NOTSPACE:process.name}\[%{NUMBER:process.pid:long}\]: )?(%{IP:source.address}|-):%{NUMBER:source.port:long} \[%{NOTSPACE:haproxy.request_date}\] %{NOTSPACE:haproxy.frontend_name}/%{NOTSPACE:haproxy.bind_name} %{GREEDYDATA:haproxy.error_message}' - '%{HAPROXY_DATE} %{IPORHOST:haproxy.source} (%{NOTSPACE:process.name}\[%{NUMBER:process.pid:long}\]: - )?%{IP:source.address}:%{NUMBER:source.port:long} \[%{NOTSPACE:haproxy.request_date}\] + )?(%{IP:source.address}|-):%{NUMBER:source.port:long} \[%{NOTSPACE:haproxy.request_date}\] %{NOTSPACE:haproxy.frontend_name} %{NOTSPACE:haproxy.backend_name}/%{NOTSPACE:haproxy.server_name} %{NUMBER:haproxy.total_waiting_time_ms:long}/%{NUMBER:haproxy.connection_wait_time_ms:long}/%{NUMBER:temp.duration:long} %{NUMBER:haproxy.bytes_read:long} %{NOTSPACE:haproxy.termination_state} %{NUMBER:haproxy.connections.active:long}/%{NUMBER:haproxy.connections.frontend:long}/%{NUMBER:haproxy.connections.backend:long}/%{NUMBER:haproxy.connections.server:long}/%{NUMBER:haproxy.connections.retries:long} @@ -71,6 +71,15 @@ processors: ignore_failure: true patterns: - ^%{IP:source.ip}$ +- grok: + field: destination.address + patterns: + - ^%{IP:destination.ip}$ + on_failure: + - set: + field: destination.domain + value: "{{destination.address}}" + ignore_empty_value: true - geoip: field: source.ip target_field: source.geo @@ -121,6 +130,10 @@ processors: field: related.ip value: "{{destination.ip}}" if: "ctx?.destination?.ip != null" +- append: + field: related.hosts + value: "{{destination.domain}}" + if: "ctx?.destination?.domain != null" - set: field: event.kind value: event diff --git a/filebeat/module/haproxy/log/test/haproxy.log b/filebeat/module/haproxy/log/test/haproxy.log index ad3550d19c9..1f50b581c73 100644 --- a/filebeat/module/haproxy/log/test/haproxy.log +++ b/filebeat/module/haproxy/log/test/haproxy.log @@ -1 +1,10 @@ Jul 30 09:03:52 localhost haproxy[32450]: 1.2.3.4:38862 [30/Jul/2018:09:03:52.726] incoming~ docs_microservice/docs 0/0/1/0/2 304 168 - - ---- 6/6/0/0/0 0/0 {docs.example.internal||} {|||} "GET /component---src-pages-index-js-4b15624544f97cf0bb8f.js HTTP/1.1" +May 22 02:22:22 server1 haproxy[5089]: -:22222 [22/May/2021:02:22:22.222] www-https~ myapp/node2 site.domain.com 0/0/0/18/18 200 200 - - ---- 222/222/2/0/0 0/0 "OPTIONS /api/v2/app/ HTTP/1.1" +Jun 22 12:02:53 node2 haproxy[23034]: -:47625 [22/Jun/2021:12:02:53.473] www-https~ app/app-node2 app.domain.com 0/0/1/17/18 302 291 - - ---- 1/1/0/0/0 0/0 "GET / HTTP/1.1" +Jun 22 12:03:01 node2 haproxy[23034]: -:47445 [22/Jun/2021:12:03:01.501] www-https~ app/node16 app.domain.com 0/0/1/55/56 200 3097 - - ---- 2/2/0/0/0 0/0 "GET /app/login/ HTTP/1.1" +Jun 22 12:03:01 node2 haproxy[23034]: -:43662 [22/Jun/2021:12:03:01.427] www-https~ app/node7 app.domain.com 0/0/1/30/31 200 1235 - - ---- 1/1/0/0/0 0/0 "GET /23rfsa/ HTTP/1.1" +Jun 22 12:02:59 node2 haproxy[23034]: -:47481 [22/Jun/2021:12:02:59.590] www-https~ app/node16 app.domain.com 0/0/3/32/35 403 142 - - ---- 1/1/0/0/0 0/0 "GET /app/event/ HTTP/1.1" +Jun 22 12:02:57 node2 haproxy[23034]: -:47642 [22/Jun/2021:12:02:55.202] www-https~ app/app-node2 app.domain.com 1/0/1/15/2606 200 325791 - - ---- 1/1/0/0/0 0/0 "GET /static/files/3rsdfas3.js HTTP/1.1" +Jun 22 12:03:08 node2 haproxy[23034]: -:11178 [22/Jun/2021:12:03:08.833] www-https~ app/node7 app.domain.com 0/0/1/29/30 404 448 - - ---- 3/3/0/0/0 0/0 "GET /favicon.ico HTTP/1.1" +Jun 22 12:03:04 node2 haproxy[23034]: -:21278 [22/Jun/2021:12:03:04.060] www-https~ app/node16 app.domain.com 0/0/2/39/41 200 1235 - - ---- 3/3/0/0/0 0/0 "GET /qfe32/ HTTP/1.1" +Jun 22 12:03:08 node3 haproxy[23034]: -:21978 [22/Jun/2021:12:03:08.339] www-https~ app/server app.domain.eu 0/0/2/45/47 404 448 - - ---- 3/3/0/0/0 0/0 "GET /dsffdssdf HTTP/1.1" diff --git a/filebeat/module/haproxy/log/test/haproxy.log-expected.json b/filebeat/module/haproxy/log/test/haproxy.log-expected.json index b8e839b8da6..9633ab57190 100644 --- a/filebeat/module/haproxy/log/test/haproxy.log-expected.json +++ b/filebeat/module/haproxy/log/test/haproxy.log-expected.json @@ -59,5 +59,439 @@ "url.extension": "js", "url.original": "/component---src-pages-index-js-4b15624544f97cf0bb8f.js", "url.path": "/component---src-pages-index-js-4b15624544f97cf0bb8f.js" + }, + { + "destination.address": "site.domain.com", + "destination.domain": "site.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 18000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "success", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "myapp", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 200, + "haproxy.connection_wait_time_ms": 0, + "haproxy.connections.active": 222, + "haproxy.connections.backend": 2, + "haproxy.connections.frontend": 222, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "OPTIONS /api/v2/app/ HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 18, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "node2", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "OPTIONS", + "http.response.bytes": 200, + "http.response.status_code": 200, + "http.version": "1.1", + "input.type": "log", + "log.offset": 260, + "process.name": "haproxy", + "process.pid": 5089, + "related.hosts": [ + "site.domain.com" + ], + "service.type": "haproxy", + "source.port": 22222, + "url.original": "/api/v2/app/", + "url.path": "/api/v2/app/" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 18000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "success", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 291, + "haproxy.connection_wait_time_ms": 1, + "haproxy.connections.active": 1, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 1, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET / HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 17, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "app-node2", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 291, + "http.response.status_code": 302, + "http.version": "1.1", + "input.type": "log", + "log.offset": 452, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 47625, + "url.original": "/", + "url.path": "/" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 56000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "success", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 3097, + "haproxy.connection_wait_time_ms": 1, + "haproxy.connections.active": 2, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 2, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /app/login/ HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 55, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "node16", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 3097, + "http.response.status_code": 200, + "http.version": "1.1", + "input.type": "log", + "log.offset": 625, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 47445, + "url.original": "/app/login/", + "url.path": "/app/login/" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 31000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "success", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 1235, + "haproxy.connection_wait_time_ms": 1, + "haproxy.connections.active": 1, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 1, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /23rfsa/ HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 30, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "node7", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 1235, + "http.response.status_code": 200, + "http.version": "1.1", + "input.type": "log", + "log.offset": 806, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 43662, + "url.original": "/23rfsa/", + "url.path": "/23rfsa/" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 35000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "failure", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 142, + "haproxy.connection_wait_time_ms": 3, + "haproxy.connections.active": 1, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 1, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /app/event/ HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 32, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "node16", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 142, + "http.response.status_code": 403, + "http.version": "1.1", + "input.type": "log", + "log.offset": 983, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 47481, + "url.original": "/app/event/", + "url.path": "/app/event/" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 2606000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "success", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 325791, + "haproxy.connection_wait_time_ms": 1, + "haproxy.connections.active": 1, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 1, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /static/files/3rsdfas3.js HTTP/1.1", + "haproxy.http.request.time_wait_ms": 1, + "haproxy.http.request.time_wait_without_data_ms": 15, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "app-node2", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 325791, + "http.response.status_code": 200, + "http.version": "1.1", + "input.type": "log", + "log.offset": 1163, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 47642, + "url.extension": "js", + "url.original": "/static/files/3rsdfas3.js", + "url.path": "/static/files/3rsdfas3.js" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 30000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "failure", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 448, + "haproxy.connection_wait_time_ms": 1, + "haproxy.connections.active": 3, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 3, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /favicon.ico HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 29, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "node7", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 448, + "http.response.status_code": 404, + "http.version": "1.1", + "input.type": "log", + "log.offset": 1365, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 11178, + "url.extension": "ico", + "url.original": "/favicon.ico", + "url.path": "/favicon.ico" + }, + { + "destination.address": "app.domain.com", + "destination.domain": "app.domain.com", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 41000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "success", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 1235, + "haproxy.connection_wait_time_ms": 2, + "haproxy.connections.active": 3, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 3, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /qfe32/ HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 39, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "node16", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 1235, + "http.response.status_code": 200, + "http.version": "1.1", + "input.type": "log", + "log.offset": 1545, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.com" + ], + "service.type": "haproxy", + "source.port": 21278, + "url.original": "/qfe32/", + "url.path": "/qfe32/" + }, + { + "destination.address": "app.domain.eu", + "destination.domain": "app.domain.eu", + "event.category": [ + "web" + ], + "event.dataset": "haproxy.log", + "event.duration": 47000000, + "event.kind": "event", + "event.module": "haproxy", + "event.outcome": "failure", + "event.timezone": "-02:00", + "fileset.name": "log", + "haproxy.backend_name": "app", + "haproxy.backend_queue": 0, + "haproxy.bytes_read": 448, + "haproxy.connection_wait_time_ms": 2, + "haproxy.connections.active": 3, + "haproxy.connections.backend": 0, + "haproxy.connections.frontend": 3, + "haproxy.connections.retries": 0, + "haproxy.connections.server": 0, + "haproxy.frontend_name": "www-https~", + "haproxy.http.request.captured_cookie": "-", + "haproxy.http.request.raw_request_line": "GET /dsffdssdf HTTP/1.1", + "haproxy.http.request.time_wait_ms": 0, + "haproxy.http.request.time_wait_without_data_ms": 45, + "haproxy.http.response.captured_cookie": "-", + "haproxy.server_name": "server", + "haproxy.server_queue": 0, + "haproxy.termination_state": "----", + "haproxy.total_waiting_time_ms": 0, + "http.request.method": "GET", + "http.response.bytes": 448, + "http.response.status_code": 404, + "http.version": "1.1", + "input.type": "log", + "log.offset": 1722, + "process.name": "haproxy", + "process.pid": 23034, + "related.hosts": [ + "app.domain.eu" + ], + "service.type": "haproxy", + "source.port": 21978, + "url.original": "/dsffdssdf", + "url.path": "/dsffdssdf" } ] \ No newline at end of file