From dee25ff885e68608cfbadc6dcc0e162c79c8eaf0 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 4 Jul 2019 11:27:01 -0500 Subject: [PATCH 001/102] Moar intervals --- heartbeat/_meta/fields.common.yml | 5 + heartbeat/docs/fields.asciidoc | 10 ++ heartbeat/heartbeat.yml | 29 +++--- heartbeat/include/fields.go | 2 +- heartbeat/monitors/wrappers/monitors.go | 122 ++++++++++++++++++++++++ heartbeat/query.txt | 44 +++++++++ 6 files changed, 197 insertions(+), 15 deletions(-) create mode 100644 heartbeat/query.txt diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 7cd6393278b7..49b69bbed096 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -63,6 +63,11 @@ description: > A token unique to a simultaneously invoked group of checks as in the case where multiple IPs are checked for a single DNS entry. + - name: continuous_status_segment + type: date + description: > + A date representing the start time of a logically contiguous segment of statuses + - key: summary title: "Monitor summary" description: diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index bc75e79a1192..316c71d71d3f 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -309,6 +309,16 @@ required: True A token unique to a simultaneously invoked group of checks as in the case where multiple IPs are checked for a single DNS entry. +type: keyword + +-- + +*`monitor.continuous_status_segment`*:: ++ +-- +A UUID representing a continuous state from the perspective of the beat. + + type: keyword -- diff --git a/heartbeat/heartbeat.yml b/heartbeat/heartbeat.yml index d5e4e300c4ce..a17621860cea 100644 --- a/heartbeat/heartbeat.yml +++ b/heartbeat/heartbeat.yml @@ -22,15 +22,20 @@ heartbeat.config.monitors: # Configure monitors inline heartbeat.monitors: - type: http - - # List or urls to query + id: localhost urls: ["http://localhost:9200"] - - # Configure task schedule schedule: '@every 10s' +- type: http + id: elastic-co + urls: ["https://www.elastic.co"] + schedule: '@every 10s' + mode: all +- type: http + id: andrewvc-com + urls: ["http://blog.andrewvc.com"] + schedule: '@every 10s' + mode: all - # Total test connection and data exchange timeout - #timeout: 16s #==================== Elasticsearch template setting ========================== @@ -86,7 +91,7 @@ setup.kibana: #============================= Elastic Cloud ================================== -# These settings simplify using Heartbeat with the Elastic Cloud (https://cloud.elastic.co/). +# These settings simplify using heartbeat with the Elastic Cloud (https://cloud.elastic.co/). # The cloud.id setting overwrites the `output.elasticsearch.hosts` and # `setup.kibana.host` options. @@ -127,16 +132,12 @@ output.elasticsearch: #ssl.key: "/etc/pki/client/cert.key" #================================ Processors ===================================== - processors: - add_observer_metadata: - # Optional, but recommended geo settings for the location Heartbeat is running in - #geo: - # Token describing this location - #name: us-east-1a + geo: + name: "${GEO_NAME:mpls-mn-us}" + location: "37.926868, -78.024902" - # Lat, Lon " - #location: "37.926868, -78.024902" #================================ Logging ===================================== diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 30721aadbcbb..5083b024ea92 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/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 4de602505820..196dc1452964 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -121,6 +121,115 @@ func addMonitorDuration(job jobs.Job) jobs.Job { } } +const FlappingThreshold time.Duration = time.Minute + +const ( + StatusUp stateStatus = iota + StatusDown + StatusMixed +) + +type stateStatus int8 + +type historicalStatus struct { + ts time.Time + status stateStatus +} + +type monitorState struct { + startedAt time.Time + status stateStatus + flapHistory []historicalStatus +} + +func (state *monitorState) isFlapping() bool { + return len(state.flapHistory) > 0 +} + +func (state *monitorState) isStateStillStable(currentStatus stateStatus) bool { + return state.status == currentStatus && state.isFlapping() +} + +func (state *monitorState) flapCompute(currentStatus stateStatus) bool { + state.flapHistory = append(state.flapHistory, historicalStatus{time.Now(), state.status}) + state.status = currentStatus + + // Figure out which values are old enough that we can discard them for our calculation + cutOff := time.Now().Add(-FlappingThreshold) + discardIndex := -1 + for idx, hs := range state.flapHistory { + if hs.ts.Before(cutOff) { + discardIndex = idx + } else { + break + } + } + // Do the discarding + if discardIndex != -1 { + state.flapHistory = state.flapHistory[discardIndex+1:] + } + + // Check to see if we are no longer flapping, and if so clear flap history + for _, hs := range state.flapHistory { + if hs.status != currentStatus { + return false + } + } + return true +} + +func NewMonitorState(currentStatus stateStatus) *monitorState { + return &monitorState{ + startedAt: time.Now(), + status: currentStatus, + } +} + +type monitorStateTracker struct { + states map[string]*monitorState +} + +func (mst *monitorStateTracker) get(monitorId string, currentStatus stateStatus) (state *monitorState) { + if state, ok := mst.states[monitorId]; ok { + if state.isFlapping() { + // Check to see if there's still an ongoing flap after recording + // the new status + if state.flapCompute(currentStatus) { + fmt.Printf("STABLE FLAP\n") + return state + } else { + fmt.Printf("EXIT FLAP\n") + state = NewMonitorState(currentStatus) + mst.states[monitorId] = state + return state + } + } else if state.status == currentStatus { + // The state is stable, no changes needed + fmt.Printf("STABLE STATE\n") + return state + } else if state.startedAt.After(time.Now().Add(-FlappingThreshold)) { + state.flapCompute(currentStatus) // record the new state to the flap history + fmt.Printf("ENTER FLAP\n") + return state + } + } + + fmt.Printf("NEW STATE\n") + // No previous state, so make a new one + state = NewMonitorState(currentStatus) + mst.states[monitorId] = state + return state +} + +func (mst *monitorStateTracker) getID(monitorId string, currentStatus stateStatus) time.Time { + return mst.get(monitorId, currentStatus).startedAt +} + +// TODO this is obviously a memory leak and for the POC only +var stateTracker = &monitorStateTracker{ + states: map[string]*monitorState{}, +} + // makeAddSummary summarizes the job, adding the `summary` field to the last event emitted. func makeAddSummary() jobs.JobWrapper { // This is a tricky method. The way this works is that we track the state across jobs in the @@ -177,7 +286,20 @@ func makeAddSummary() jobs.JobWrapper { // After last job if state.remaining == 0 { + monitorId, _ := event.GetValue("monitor.id") + var trackerStatus stateStatus + if state.down == 0 { + trackerStatus = StatusUp + } else if state.up > 0 { + trackerStatus = StatusMixed + } else { + trackerStatus = StatusDown + } + monitorIdString, _ := monitorId.(string) eventext.MergeEventFields(event, common.MapStr{ + "monitor": common.MapStr{ + "continuous_status_segment": stateTracker.getID(monitorIdString, trackerStatus), + }, "summary": common.MapStr{ "up": state.up, "down": state.down, diff --git a/heartbeat/query.txt b/heartbeat/query.txt new file mode 100644 index 000000000000..dc76ccf5b55b --- /dev/null +++ b/heartbeat/query.txt @@ -0,0 +1,44 @@ +GET /heartbeat-*/_search?size=0 +{ + "query": { + "match": { + "monitor.id": "localhost" + } + }, + "aggs": { + "dateHist": { + "auto_date_histogram": { + "field": "@timestamp", + "buckets": 10 + }, + "aggs": { + "location": { + "terms": { + "field": "observer.geo.name", + "missing": "N/A" + }, + "aggs": { + "css": { + "terms": { + "field": "monitor.continuous_status_segment", + "order": {"_key": "asc"} + }, + "aggs": { + "up": { + "sum": { + "field": "summary.up" + } + }, + "down": { + "sum": { + "field": "summary.down" + } + } + } + } + } + } + } + } + } +} From a3a7cbd2c038725bb1c7f71fba5595574428dd66 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 8 Jul 2019 16:18:43 -0500 Subject: [PATCH 002/102] Checkpoint --- heartbeat/heartbeat.yml | 2 +- heartbeat/monitors/wrappers/monitors.go | 27 +++++++++++++++++-------- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/heartbeat/heartbeat.yml b/heartbeat/heartbeat.yml index a17621860cea..552bbb9dcec9 100644 --- a/heartbeat/heartbeat.yml +++ b/heartbeat/heartbeat.yml @@ -135,7 +135,7 @@ output.elasticsearch: processors: - add_observer_metadata: geo: - name: "${GEO_NAME:mpls-mn-us}" + name: "${GEO_NAME}" location: "37.926868, -78.024902" diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 196dc1452964..ad46e8a8d3c9 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -65,13 +65,25 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool) jobs.JobWr thisID = fmt.Sprintf("%s-%x", id, urlHash) } + status, _ := event.Fields.GetValue("monitor.status") + var trackerStatus stateStatus + if status == "down" { + trackerStatus = StatusDown + } else { + trackerStatus = StatusUp + } + ip, _ := event.Fields.GetValue("monitor.ip") + trackerId := fmt.Sprintf("%s-%s", id, ip) + cssId := stateTracker.getID(trackerId, trackerStatus) + eventext.MergeEventFields( event, common.MapStr{ "monitor": common.MapStr{ - "id": thisID, - "name": name, - "type": typ, + "id": thisID, + "name": name, + "type": typ, + "continuous_status_segment": cssId, }, }, ) @@ -88,6 +100,7 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool) jobs.JobWr func addMonitorStatus(origJob jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { cont, err := origJob(event) + fields := common.MapStr{ "monitor": common.MapStr{ "status": look.Status(err), @@ -297,12 +310,10 @@ func makeAddSummary() jobs.JobWrapper { } monitorIdString, _ := monitorId.(string) eventext.MergeEventFields(event, common.MapStr{ - "monitor": common.MapStr{ - "continuous_status_segment": stateTracker.getID(monitorIdString, trackerStatus), - }, "summary": common.MapStr{ - "up": state.up, - "down": state.down, + "continuous_status_segment": stateTracker.getID(monitorIdString, trackerStatus), + "up": state.up, + "down": state.down, }, }) resetState() From 72fab362f74f708d3351e292ccef6c595349c298 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 8 Jul 2019 22:46:37 -0500 Subject: [PATCH 003/102] Checkpoint --- dev-tools/dummy_http/main.go | 188 ++++++++++++++++++++++++ heartbeat/heartbeat.yml | 18 +-- heartbeat/monitors/wrappers/monitors.go | 9 +- 3 files changed, 205 insertions(+), 10 deletions(-) create mode 100644 dev-tools/dummy_http/main.go diff --git a/dev-tools/dummy_http/main.go b/dev-tools/dummy_http/main.go new file mode 100644 index 000000000000..29729061d22a --- /dev/null +++ b/dev-tools/dummy_http/main.go @@ -0,0 +1,188 @@ +package main + +import ( + "fmt" + "math/rand" + "net/http" + "net/url" + "os" + "regexp" + "strconv" + "strings" + "sync" + "sync/atomic" + "time" +) + +// An URL like /pattern?r='200x50,404x20,200|500x30' +// The above pattern would return 50 200 responses, then 20 404s, then randomly return a mix of 200 and 500 +// responses 30 times + +func main() { + states := &sync.Map{} + + var reqs uint64 = 0 + + http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) { + atomic.AddUint64(&reqs, 1) + + writer.Write([]byte("Dummy HTTP Server")) + }) + + http.HandleFunc("/pattern", func(writer http.ResponseWriter, request *http.Request) { + atomic.AddUint64(&reqs, 1) + + status, body := handlePattern(states, request.URL) + writer.WriteHeader(status) + writer.Write([]byte(body)) + }) + + go func() { + for { + time.Sleep(time.Second * 10) + r := atomic.LoadUint64(&reqs) + fmt.Printf("Processed %d reqs\n", r) + } + }() + + port := 5678 + fmt.Printf("Starting server on port %d\n", port) + err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil) + if err != nil { + fmt.Printf("Could not start server: %s", err) + os.Exit(1) + } +} + +type responsePattern struct { + httpStatuses []int + httpStatusesLen int + countLimit int +} + +func (rp *responsePattern) next() (status int, body string) { + var idx int + if rp.httpStatusesLen > 1 { + fmt.Printf("INTN %d\n", rp.httpStatusesLen) + idx = rand.Intn(rp.httpStatusesLen) + } else { + idx = 0 + } + status = rp.httpStatuses[idx] + return status, strconv.Itoa(status) +} + +type responsePatternSequence struct { + currentPatternIdx int + currentPattern *responsePattern + currentPatternCount int + patterns []*responsePattern + shuffle bool + mtx sync.Mutex +} + +func (ps *responsePatternSequence) next() (status int, body string) { + ps.mtx.Lock() + ps.mtx.Unlock() + + if ps.currentPatternCount >= ps.currentPattern.countLimit { + ps.advancePattern() + } + + ps.currentPatternCount = ps.currentPatternCount + 1 + return ps.currentPattern.next() +} + +func (ps *responsePatternSequence) advancePattern() { + if ps.shuffle { + ps.currentPatternIdx = rand.Intn(len(ps.patterns)) - 1 + ps.currentPattern = ps.patterns[ps.currentPatternIdx] + } else { + var nextIdx = ps.currentPatternIdx + 1 + if nextIdx == len(ps.patterns) { + nextIdx = 0 + } + ps.currentPatternIdx = nextIdx + ps.currentPattern = ps.patterns[nextIdx] + } + + ps.currentPatternCount = 0 +} + +var statusListRegexp = regexp.MustCompile("^[|\\d]+$") + +func handlePattern(states *sync.Map, url *url.URL) (status int, body string) { + query := url.Query() + + rpsInter, ok := states.Load(url.RawQuery) + var rps *responsePatternSequence + if !ok { + patterns, err := compilePatterns(query.Get("r")) + if err != nil { + return 400, err.Error() + } + rps = NewResponsePatternSequence(patterns, query.Get("shuffle") == "true") + states.Store(url.RawQuery, rps) + } else { + rps = rpsInter.(*responsePatternSequence) + } + + return rps.next() +} + +func NewResponsePatternSequence(patterns []*responsePattern, shuffle bool) *responsePatternSequence { + ps := responsePatternSequence{ + currentPatternIdx: 0, + currentPattern: patterns[0], + currentPatternCount: 0, + patterns: patterns, + shuffle: shuffle, + mtx: sync.Mutex{}, + } + + return &ps +} + +func compilePatterns(patternsStr string) (patterns []*responsePattern, err error) { + splitPatterns := strings.Split(patternsStr, ",") + + for _, patternStr := range splitPatterns { + rp, err := compilePattern(patternStr) + if err != nil { + return nil, err + } + patterns = append(patterns, rp) + } + + return patterns, nil +} + +func compilePattern(patternStr string) (*responsePattern, error) { + rp := responsePattern{} + + splitPattern := strings.Split(patternStr, "x") + if len(splitPattern) != 2 { + return nil, fmt.Errorf("Bad pattern '%s', expected a STATUSxCOUNT as pattern. Got %s") + } + + statusDefStr := splitPattern[0] + if statusListRegexp.MatchString(statusDefStr) { + statuses := strings.Split(statusDefStr, "|") + for _, statusStr := range statuses { + status, _ := strconv.Atoi(statusStr) + rp.httpStatuses = append(rp.httpStatuses, status) + } + rp.httpStatusesLen = len(rp.httpStatuses) + } else { + return nil, fmt.Errorf("Expected a | separated list of numbers for status code def, got '%s'", statusDefStr) + + } + + count, err := strconv.Atoi(splitPattern[1]) + if err != nil { + return nil, fmt.Errorf("Repeat def should be an int, got '%s'", splitPattern[1]) + } + rp.countLimit = count + + return &rp, nil +} diff --git a/heartbeat/heartbeat.yml b/heartbeat/heartbeat.yml index 552bbb9dcec9..2ffd8700936c 100644 --- a/heartbeat/heartbeat.yml +++ b/heartbeat/heartbeat.yml @@ -22,18 +22,18 @@ heartbeat.config.monitors: # Configure monitors inline heartbeat.monitors: - type: http - id: localhost - urls: ["http://localhost:9200"] - schedule: '@every 10s' + id: occasional-issues + urls: ["http://localhost:5678/pattern?r=200x220,500x4"] + schedule: '@every 1s' - type: http - id: elastic-co - urls: ["https://www.elastic.co"] - schedule: '@every 10s' + id: always-green + urls: ["http://localhost:5678/"] + schedule: '@every 1s' mode: all - type: http - id: andrewvc-com - urls: ["http://blog.andrewvc.com"] - schedule: '@every 10s' + id: always-down + urls: ["http://localhost:5678/pattern?r=500x4,404x4"] + schedule: '@every 1s' mode: all diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index ad46e8a8d3c9..7dc24dea4d8c 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -74,7 +74,10 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool) jobs.JobWr } ip, _ := event.Fields.GetValue("monitor.ip") trackerId := fmt.Sprintf("%s-%s", id, ip) + + stateTrackerMtx.Lock() cssId := stateTracker.getID(trackerId, trackerStatus) + stateTrackerMtx.Unlock() eventext.MergeEventFields( event, @@ -242,6 +245,7 @@ func (mst *monitorStateTracker) getID(monitorId string, currentStatus stateStatu var stateTracker = &monitorStateTracker{ states: map[string]*monitorState{}, } +var stateTrackerMtx = sync.Mutex{} // makeAddSummary summarizes the job, adding the `summary` field to the last event emitted. func makeAddSummary() jobs.JobWrapper { @@ -309,9 +313,12 @@ func makeAddSummary() jobs.JobWrapper { trackerStatus = StatusDown } monitorIdString, _ := monitorId.(string) + stateTrackerMtx.Lock() + cssId := stateTracker.getID(monitorIdString, trackerStatus) + stateTrackerMtx.Unlock() eventext.MergeEventFields(event, common.MapStr{ "summary": common.MapStr{ - "continuous_status_segment": stateTracker.getID(monitorIdString, trackerStatus), + "continuous_status_segment": cssId, "up": state.up, "down": state.down, }, From 22e7c129a04c8eb33ec773c7eccc12a0f15fcde8 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Jul 2019 16:53:41 -0500 Subject: [PATCH 004/102] Checkpoint --- heartbeat/monitors/wrappers/monitors.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 7dc24dea4d8c..53805ebef91a 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -203,6 +203,7 @@ func NewMonitorState(currentStatus stateStatus) *monitorState { type monitorStateTracker struct { states map[string]*monitorState + mtx sync.Mutex } func (mst *monitorStateTracker) get(monitorId string, currentStatus stateStatus) (state *monitorState) { @@ -238,12 +239,15 @@ func (mst *monitorStateTracker) get(monitorId string, currentStatus stateStatus) } func (mst *monitorStateTracker) getID(monitorId string, currentStatus stateStatus) time.Time { + mst.mtx.Lock() + defer mst.mtx.Unlock() return mst.get(monitorId, currentStatus).startedAt } // TODO this is obviously a memory leak and for the POC only var stateTracker = &monitorStateTracker{ states: map[string]*monitorState{}, + mtx: sync.Mutex{}, } var stateTrackerMtx = sync.Mutex{} From b46f81d09d25e1e7aaad4f94f2d3812709595fab Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 13 Sep 2019 09:27:01 -0500 Subject: [PATCH 005/102] [Heartbeat] Report next_run info per event Add support for `next_run` and `next_run_in` fields to the monitors object in events. This allows for the computation of SLA statistics in elasticsearch. --- heartbeat/_meta/fields.common.yml | 15 +++++++++ heartbeat/docs/fields.asciidoc | 25 ++++++++++++++ heartbeat/hbtest/hbtestutil.go | 28 +++++++++------- heartbeat/hbtestllext/isdefs.go | 34 ++++++++++++++++++++ heartbeat/hbtestllext/validators.go | 30 +++++++++++++++++ heartbeat/include/fields.go | 2 +- heartbeat/monitors/active/http/http_test.go | 8 +++-- heartbeat/monitors/active/tcp/tcp_test.go | 8 +++-- heartbeat/monitors/mocks_test.go | 3 ++ heartbeat/monitors/monitor.go | 2 +- heartbeat/monitors/pluginconf.go | 11 ++++--- heartbeat/monitors/wrappers/monitors.go | 18 +++++++---- heartbeat/monitors/wrappers/monitors_test.go | 11 ++++++- 13 files changed, 167 insertions(+), 28 deletions(-) create mode 100644 heartbeat/hbtestllext/isdefs.go create mode 100644 heartbeat/hbtestllext/validators.go diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 7cd6393278b7..ec60865096c4 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -63,6 +63,21 @@ description: > A token unique to a simultaneously invoked group of checks as in the case where multiple IPs are checked for a single DNS entry. + - name: next_run + type: date + description: > + The next expected time this monitor will run on the reporting heartbeat agent based on its schedule. + It may run sooner than this if the heartbeat daemon is restarted, + and it may run later than this time for any number of reasons + - name: next_run_in + type: group + description: Duration between when this run occurred and when the next one is expected. + fields: + - name: us + type: long + description: Duration between when this run occurred and when the next one is expected in microseconds. + + - key: summary title: "Monitor summary" description: diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index ee9baafa1415..0c0513aa8cd3 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -313,6 +313,31 @@ type: keyword -- +*`monitor.next_run`*:: ++ +-- +The next expected time this monitor will run on the reporting heartbeat agent based on its schedule. It may run sooner than this if the heartbeat daemon is restarted, and it may run later than this time for any number of reasons + + +type: date + +-- + +[float] +=== next_run_in + +Duration between when this run occurred and when the next one is expected. + + +*`monitor.next_run_in.us`*:: ++ +-- +Duration between when this run occurred and when the next one is expected in microseconds. + +type: long + +-- + [[exported-fields-docker-processor]] == Docker fields diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index bba01d8778d5..bc7e62f0fda7 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -30,6 +30,8 @@ import ( "strings" "testing" + "github.com/elastic/beats/heartbeat/hbtestllext" + "github.com/stretchr/testify/require" "github.com/elastic/beats/heartbeat/monitors/wrappers" @@ -107,17 +109,21 @@ func BaseChecks(ip string, status string, typ string) validator.Validator { } else { ipCheck = isdef.Optional(isdef.IsEqual(ip)) } - return lookslike.MustCompile(map[string]interface{}{ - "monitor": map[string]interface{}{ - "ip": ipCheck, - "duration.us": isdef.IsDuration, - "status": status, - "id": isdef.IsNonEmptyString, - "name": isdef.IsString, - "type": typ, - "check_group": isdef.IsString, - }, - }) + + return lookslike.Compose( + lookslike.MustCompile(map[string]interface{}{ + "monitor": map[string]interface{}{ + "ip": ipCheck, + "duration.us": isdef.IsDuration, + "status": status, + "id": isdef.IsNonEmptyString, + "name": isdef.IsString, + "type": typ, + "check_group": isdef.IsString, + }, + }), + hbtestllext.MonitorNextRunValidator, + ) } // SummaryChecks validates the "summary" field and its subfields. diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go new file mode 100644 index 000000000000..e6b1ff3f78c1 --- /dev/null +++ b/heartbeat/hbtestllext/isdefs.go @@ -0,0 +1,34 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package hbtestllext + +import ( + "time" + + "github.com/elastic/go-lookslike/isdef" + "github.com/elastic/go-lookslike/llpath" + "github.com/elastic/go-lookslike/llresult" +) + +var IsTime = isdef.Is("time", func(path llpath.Path, v interface{}) *llresult.Results { + _, ok := v.(time.Time) + if !ok { + return llresult.SimpleResult(path, false, "expected a time.Time") + } + return llresult.ValidResult(path) +}) diff --git a/heartbeat/hbtestllext/validators.go b/heartbeat/hbtestllext/validators.go new file mode 100644 index 000000000000..aaec0eaa6107 --- /dev/null +++ b/heartbeat/hbtestllext/validators.go @@ -0,0 +1,30 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package hbtestllext + +import ( + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/isdef" +) + +var MonitorNextRunValidator = lookslike.MustCompile(map[string]interface{}{ + "monitor": map[string]interface{}{ + "next_run": IsTime, + "next_run_in.us": isdef.IsDuration, + }, +}) diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index cca1810fdd95..8cbc2a929d98 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/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index be5055e33069..43d2de34a104 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -31,6 +31,8 @@ import ( "testing" "time" + schedule "github.com/elastic/beats/heartbeat/scheduler/schedule" + "github.com/stretchr/testify/require" "github.com/elastic/beats/heartbeat/hbtest" @@ -71,7 +73,8 @@ func testTLSRequest(t *testing.T, testURL string, extraConfig map[string]interfa jobs, endpoints, err := create("tls", config) require.NoError(t, err) - job := wrappers.WrapCommon(jobs, "tls", "", "http")[0] + sched, _ := schedule.Parse("@every 1s") + job := wrappers.WrapCommon(jobs, "tls", "", "http", sched)[0] event := &beat.Event{} _, err = job(event) @@ -271,7 +274,8 @@ func TestLargeResponse(t *testing.T) { jobs, _, err := create("largeresp", config) require.NoError(t, err) - job := wrappers.WrapCommon(jobs, "test", "", "http")[0] + sched, _ := schedule.Parse("@every 1s") + job := wrappers.WrapCommon(jobs, "test", "", "http", sched)[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/active/tcp/tcp_test.go b/heartbeat/monitors/active/tcp/tcp_test.go index 83230ef7762b..4e4ee70d5dca 100644 --- a/heartbeat/monitors/active/tcp/tcp_test.go +++ b/heartbeat/monitors/active/tcp/tcp_test.go @@ -28,6 +28,8 @@ import ( "strconv" "testing" + "github.com/elastic/beats/heartbeat/scheduler/schedule" + "github.com/elastic/go-lookslike/isdef" "github.com/stretchr/testify/require" @@ -58,7 +60,8 @@ func testTCPConfigCheck(t *testing.T, configMap common.MapStr, host string, port jobs, endpoints, err := create("tcp", config) require.NoError(t, err) - job := wrappers.WrapCommon(jobs, "test", "", "tcp")[0] + sched, _ := schedule.Parse("@every 1s") + job := wrappers.WrapCommon(jobs, "test", "", "tcp", sched)[0] event := &beat.Event{} _, err = job(event) @@ -81,7 +84,8 @@ func testTLSTCPCheck(t *testing.T, host string, port uint16, certFileName string jobs, endpoints, err := create("tcp", config) require.NoError(t, err) - job := wrappers.WrapCommon(jobs, "test", "", "tcp")[0] + sched, _ := schedule.Parse("@every 1s") + job := wrappers.WrapCommon(jobs, "test", "", "tcp", sched)[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/mocks_test.go b/heartbeat/monitors/mocks_test.go index 4c71775fe3fa..642f0d1ae0e3 100644 --- a/heartbeat/monitors/mocks_test.go +++ b/heartbeat/monitors/mocks_test.go @@ -23,6 +23,8 @@ import ( "sync" "testing" + "github.com/elastic/beats/heartbeat/hbtestllext" + "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/validator" @@ -116,6 +118,7 @@ func mockEventMonitorValidator(id string) validator.Validator { "check_group": isdef.IsString, }, }), + hbtestllext.MonitorNextRunValidator, hbtest.SummaryChecks(1, 0), lookslike.MustCompile(mockEventCustomFields()), )) diff --git a/heartbeat/monitors/monitor.go b/heartbeat/monitors/monitor.go index c11fecca2c04..a74b98b30191 100644 --- a/heartbeat/monitors/monitor.go +++ b/heartbeat/monitors/monitor.go @@ -163,7 +163,7 @@ func newMonitorUnsafe( } rawJobs, endpoints, err := monitorPlugin.create(config) - wrappedJobs := wrappers.WrapCommon(rawJobs, m.id, m.name, m.typ) + wrappedJobs := wrappers.WrapCommon(rawJobs, m.id, m.name, m.typ, mpi.Schedule) m.endpoints = endpoints if err != nil { diff --git a/heartbeat/monitors/pluginconf.go b/heartbeat/monitors/pluginconf.go index 26df3252eedd..eae200326c48 100644 --- a/heartbeat/monitors/pluginconf.go +++ b/heartbeat/monitors/pluginconf.go @@ -20,6 +20,8 @@ package monitors import ( "github.com/pkg/errors" + "github.com/elastic/beats/heartbeat/scheduler/schedule" + "github.com/elastic/beats/libbeat/common" ) @@ -28,10 +30,11 @@ var ErrPluginDisabled = errors.New("Monitor not loaded, plugin is disabled") // MonitorPluginInfo represents the generic configuration options around a monitor plugin. type MonitorPluginInfo struct { - ID string `config:"id"` - Name string `config:"name"` - Type string `config:"type" validate:"required"` - Enabled bool `config:"enabled"` + ID string `config:"id"` + Name string `config:"name"` + Type string `config:"type" validate:"required"` + Schedule *schedule.Schedule `config:"schedule" validate:"required"` + Enabled bool `config:"enabled"` } func pluginInfo(config *common.Config) (MonitorPluginInfo, error) { diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 4de602505820..1f23c1f8d5a8 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -22,6 +22,8 @@ import ( "sync" "time" + "github.com/elastic/beats/heartbeat/scheduler" + "github.com/gofrs/uuid" "github.com/mitchellh/hashstructure" "github.com/pkg/errors" @@ -35,21 +37,21 @@ import ( ) // WrapCommon applies the common wrappers that all monitor jobs get. -func WrapCommon(js []jobs.Job, id string, name string, typ string) []jobs.Job { +func WrapCommon(js []jobs.Job, id string, name string, typ string, schedule scheduler.Schedule) []jobs.Job { return jobs.WrapAllSeparately( jobs.WrapAll( js, addMonitorStatus, addMonitorDuration, ), func() jobs.JobWrapper { - return addMonitorMeta(id, name, typ, len(js) > 1) + return addMonitorMeta(id, name, typ, len(js) > 1, schedule) }, func() jobs.JobWrapper { return makeAddSummary() }) } // addMonitorMeta adds the id, name, and type fields to the monitor. -func addMonitorMeta(id string, name string, typ string, isMulti bool) jobs.JobWrapper { +func addMonitorMeta(id string, name string, typ string, isMulti bool, schedule scheduler.Schedule) jobs.JobWrapper { return func(job jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { cont, e := job(event) @@ -65,13 +67,17 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool) jobs.JobWr thisID = fmt.Sprintf("%s-%x", id, urlHash) } + now := time.Now() + nextRun := schedule.Next(now) eventext.MergeEventFields( event, common.MapStr{ "monitor": common.MapStr{ - "id": thisID, - "name": name, - "type": typ, + "id": thisID, + "name": name, + "type": typ, + "next_run": nextRun, + "next_run_in": common.MapStr{"us": nextRun.Sub(now)}, }, }, ) diff --git a/heartbeat/monitors/wrappers/monitors_test.go b/heartbeat/monitors/wrappers/monitors_test.go index 8f4d558b6fce..5025e64fad55 100644 --- a/heartbeat/monitors/wrappers/monitors_test.go +++ b/heartbeat/monitors/wrappers/monitors_test.go @@ -22,6 +22,9 @@ import ( "net/url" "testing" + "github.com/elastic/beats/heartbeat/hbtestllext" + "github.com/elastic/beats/heartbeat/scheduler/schedule" + "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/validator" @@ -54,7 +57,8 @@ type testDef struct { func testCommonWrap(t *testing.T, tt testDef) { t.Run(tt.name, func(t *testing.T) { - wrapped := WrapCommon(tt.jobs, tt.fields.id, tt.fields.name, tt.fields.typ) + schedule, _ := schedule.Parse("@every 1s") + wrapped := WrapCommon(tt.jobs, tt.fields.id, tt.fields.name, tt.fields.typ, schedule) results, err := jobs.ExecJobsAndConts(t, wrapped) assert.NoError(t, err) @@ -93,6 +97,7 @@ func TestSimpleJob(t *testing.T) { "check_group": isdef.IsString, }, }), + hbtestllext.MonitorNextRunValidator, summaryValidator(1, 0), )}, nil, @@ -127,6 +132,7 @@ func TestErrorJob(t *testing.T) { []validator.Validator{ lookslike.Compose( errorJobValidator, + hbtestllext.MonitorNextRunValidator, summaryValidator(0, 1), )}, nil, @@ -151,6 +157,7 @@ func TestMultiJobNoConts(t *testing.T) { "check_group": uniqScope.IsUniqueTo("check_group"), }, }), + hbtestllext.MonitorNextRunValidator, summaryValidator(1, 0), ) } @@ -199,6 +206,7 @@ func TestMultiJobConts(t *testing.T) { "check_group": uniqScope.IsUniqueTo(u), }, }), + hbtestllext.MonitorNextRunValidator, ) } @@ -258,6 +266,7 @@ func TestMultiJobContsCancelledEvents(t *testing.T) { "check_group": uniqScope.IsUniqueTo(u), }, }), + hbtestllext.MonitorNextRunValidator, ) } From e90a046e9502ab94b1eef650f478955bcca17f9a Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 13 Sep 2019 09:31:08 -0500 Subject: [PATCH 006/102] Add changelog --- CHANGELOG.next.asciidoc | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 246c248789be..5383d7622af7 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -310,6 +310,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Enable `add_observer_metadata` processor in default config. {pull}11394[11394] - Record HTTP body metadata and optionally contents in `http.response.body.*` fields. {pull}13022[13022] +- Add `monitor.next_run` and `monitor.next_run_in` fields. {pull}13672[13672] *Journalbeat* From cdeac6433217ea60711b9a150a67489af2d6a6eb Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 18 Sep 2019 07:28:27 -0500 Subject: [PATCH 007/102] Incorporate PR feedback --- heartbeat/hbtestllext/isdefs.go | 1 + heartbeat/hbtestllext/validators.go | 1 + heartbeat/monitors/pluginconf.go | 4 +--- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go index e6b1ff3f78c1..b913c6c40daa 100644 --- a/heartbeat/hbtestllext/isdefs.go +++ b/heartbeat/hbtestllext/isdefs.go @@ -25,6 +25,7 @@ import ( "github.com/elastic/go-lookslike/llresult" ) +// IsTime checks that the value is a time.Time instance. var IsTime = isdef.Is("time", func(path llpath.Path, v interface{}) *llresult.Results { _, ok := v.(time.Time) if !ok { diff --git a/heartbeat/hbtestllext/validators.go b/heartbeat/hbtestllext/validators.go index aaec0eaa6107..7c19b37a753f 100644 --- a/heartbeat/hbtestllext/validators.go +++ b/heartbeat/hbtestllext/validators.go @@ -22,6 +22,7 @@ import ( "github.com/elastic/go-lookslike/isdef" ) +// MonitorNextRunValidator is tests for the `next_run` and `next_run_in.us` keys. var MonitorNextRunValidator = lookslike.MustCompile(map[string]interface{}{ "monitor": map[string]interface{}{ "next_run": IsTime, diff --git a/heartbeat/monitors/pluginconf.go b/heartbeat/monitors/pluginconf.go index eae200326c48..769e7c589ae6 100644 --- a/heartbeat/monitors/pluginconf.go +++ b/heartbeat/monitors/pluginconf.go @@ -18,11 +18,9 @@ package monitors import ( - "github.com/pkg/errors" - "github.com/elastic/beats/heartbeat/scheduler/schedule" - "github.com/elastic/beats/libbeat/common" + "github.com/pkg/errors" ) // ErrPluginDisabled is returned when the monitor plugin is marked as disabled. From 077be58e3014dce91ad542e9bdb78a47f4a3f360 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 28 Oct 2019 13:46:18 -0500 Subject: [PATCH 008/102] Checkpoint --- heartbeat/scheduler/schedule/quantize/quantize.go | 1 + 1 file changed, 1 insertion(+) create mode 100644 heartbeat/scheduler/schedule/quantize/quantize.go diff --git a/heartbeat/scheduler/schedule/quantize/quantize.go b/heartbeat/scheduler/schedule/quantize/quantize.go new file mode 100644 index 000000000000..d3912b6384a0 --- /dev/null +++ b/heartbeat/scheduler/schedule/quantize/quantize.go @@ -0,0 +1 @@ +package quantize From b06323fc481db0f943fd9d5e42aac628bcc353b6 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 28 Oct 2019 13:46:29 -0500 Subject: [PATCH 009/102] Checkpoint --- heartbeat/_meta/fields.common.yml | 11 + heartbeat/docs/fields.asciidoc | 20 + heartbeat/heartbeat.yml | 2164 +++++++++++++++-- heartbeat/include/fields.go | 2 +- heartbeat/monitors/wrappers/monitors.go | 33 +- .../scheduler/schedule/quantize/quantize.go | 9 + heartbeat/scheduler/schedule/schedule.go | 12 +- heartbeat/scheduler/schedule/schedule_test.go | 24 +- libbeat/mapping/field.go | 11 +- 9 files changed, 2097 insertions(+), 189 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index ec60865096c4..2e1cc73a12f1 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -63,6 +63,17 @@ description: > A token unique to a simultaneously invoked group of checks as in the case where multiple IPs are checked for a single DNS entry. + - name: quantized_range + type: date_range + description: > + Time range this ping reported on quantized based on timestamp + + - name: quantized_grace_range + type: date_range + description: > + Same as start time as quantized range but twice as long. This should overlap with the next check. + Useful in queries where you want the latest value. + - name: next_run type: date description: > diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index 0c0513aa8cd3..d19c95e03e13 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -313,6 +313,26 @@ type: keyword -- +*`monitor.quantized_range`*:: ++ +-- +Time range this ping reported on quantized based on timestamp + + +type: date_range + +-- + +*`monitor.quantized_grace_range`*:: ++ +-- +Same as start time as quantized range but twice as long. This should overlap with the next check. Useful in queries where you want the latest value. + + +type: date_range + +-- + *`monitor.next_run`*:: + -- diff --git a/heartbeat/heartbeat.yml b/heartbeat/heartbeat.yml index c21b19615141..650d443a5e14 100644 --- a/heartbeat/heartbeat.yml +++ b/heartbeat/heartbeat.yml @@ -1,165 +1,2007 @@ -################### Heartbeat Configuration Example ######################### - -# This file is an example configuration file highlighting only some common options. -# The heartbeat.reference.yml file in the same directory contains all the supported options -# with detailed comments. You can use it for reference. -# -# You can find the full configuration reference here: -# https://www.elastic.co/guide/en/beats/heartbeat/index.html - -############################# Heartbeat ###################################### - -# Define a directory to load monitor definitions from. Definitions take the form -# of individual yaml files. -heartbeat.config.monitors: - # Directory + glob pattern to search for configuration files - path: ${path.config}/monitors.d/*.yml - # If enabled, heartbeat will periodically check the config.monitors path for changes - reload.enabled: false - # How often to check for changes - reload.period: 5s - -# Configure monitors inline heartbeat.monitors: -- type: http - - # List or urls to query - urls: ["http://localhost:9200"] - - # Configure task schedule - schedule: '@every 10s' - - # Total test connection and data exchange timeout - #timeout: 16s - -#==================== Elasticsearch template setting ========================== - -setup.template.settings: - index.number_of_shards: 1 - index.codec: best_compression - #_source.enabled: false - -#================================ General ===================================== - -# The name of the shipper that publishes the network data. It can be used to group -# all the transactions sent by a single shipper in the web interface. -#name: - -# The tags of the shipper are included in their own field with each -# transaction published. -#tags: ["service-X", "web-tier"] - -# Optional fields that you can specify to add additional information to the -# output. -#fields: -# env: staging - - -#============================== Kibana ===================================== - -# Starting with Beats version 6.0.0, the dashboards are loaded via the Kibana API. -# This requires a Kibana endpoint configuration. -setup.kibana: - - # Kibana Host - # Scheme and port can be left out and will be set to the default (http and 5601) - # In case you specify and additional path, the scheme is required: http://localhost:5601/path - # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601 - #host: "localhost:5601" - - # Kibana Space ID - # ID of the Kibana Space into which the dashboards should be loaded. By default, - # the Default Space will be used. - #space.id: - -#============================= Elastic Cloud ================================== - -# These settings simplify using Heartbeat with the Elastic Cloud (https://cloud.elastic.co/). - -# The cloud.id setting overwrites the `output.elasticsearch.hosts` and -# `setup.kibana.host` options. -# You can find the `cloud.id` in the Elastic Cloud web UI. -#cloud.id: - -# The cloud.auth setting overwrites the `output.elasticsearch.username` and -# `output.elasticsearch.password` settings. The format is `:`. -#cloud.auth: - -#================================ Outputs ===================================== - -# Configure what output to use when sending the data collected by the beat. - -#-------------------------- Elasticsearch output ------------------------------ +- {id: 0000-intermittent, name: Test 0000 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0001-up, name: Test 0001 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0002-up, name: Test 0002 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0003-up, name: Test 0003 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0004-up, name: Test 0004 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0005-up, name: Test 0005 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0006-up, name: Test 0006 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0007-up, name: Test 0007 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0008-up, name: Test 0008 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0009-up, name: Test 0009 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0010-down, name: Test 0010 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0011-up, name: Test 0011 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0012-up, name: Test 0012 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0013-up, name: Test 0013 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0014-up, name: Test 0014 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0015-intermittent, name: Test 0015 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0016-up, name: Test 0016 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0017-up, name: Test 0017 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0018-up, name: Test 0018 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0019-up, name: Test 0019 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0020-down, name: Test 0020 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0021-up, name: Test 0021 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0022-up, name: Test 0022 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0023-up, name: Test 0023 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0024-up, name: Test 0024 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0025-up, name: Test 0025 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0026-up, name: Test 0026 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0027-up, name: Test 0027 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0028-up, name: Test 0028 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0029-up, name: Test 0029 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0030-intermittent, name: Test 0030 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0031-up, name: Test 0031 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0032-up, name: Test 0032 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0033-up, name: Test 0033 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0034-up, name: Test 0034 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0035-up, name: Test 0035 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0036-up, name: Test 0036 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0037-up, name: Test 0037 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0038-up, name: Test 0038 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0039-up, name: Test 0039 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0040-down, name: Test 0040 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0041-up, name: Test 0041 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0042-up, name: Test 0042 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0043-up, name: Test 0043 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0044-up, name: Test 0044 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0045-intermittent, name: Test 0045 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0046-up, name: Test 0046 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0047-up, name: Test 0047 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0048-up, name: Test 0048 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0049-up, name: Test 0049 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0050-down, name: Test 0050 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0051-up, name: Test 0051 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0052-up, name: Test 0052 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0053-up, name: Test 0053 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0054-up, name: Test 0054 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0055-up, name: Test 0055 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0056-up, name: Test 0056 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0057-up, name: Test 0057 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0058-up, name: Test 0058 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0059-up, name: Test 0059 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0060-intermittent, name: Test 0060 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0061-up, name: Test 0061 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0062-up, name: Test 0062 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0063-up, name: Test 0063 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0064-up, name: Test 0064 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0065-up, name: Test 0065 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0066-up, name: Test 0066 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0067-up, name: Test 0067 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0068-up, name: Test 0068 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0069-up, name: Test 0069 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0070-down, name: Test 0070 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0071-up, name: Test 0071 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0072-up, name: Test 0072 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0073-up, name: Test 0073 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0074-up, name: Test 0074 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0075-intermittent, name: Test 0075 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0076-up, name: Test 0076 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0077-up, name: Test 0077 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0078-up, name: Test 0078 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0079-up, name: Test 0079 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0080-down, name: Test 0080 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0081-up, name: Test 0081 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0082-up, name: Test 0082 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0083-up, name: Test 0083 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0084-up, name: Test 0084 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0085-up, name: Test 0085 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0086-up, name: Test 0086 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0087-up, name: Test 0087 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0088-up, name: Test 0088 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0089-up, name: Test 0089 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0090-intermittent, name: Test 0090 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0091-up, name: Test 0091 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0092-up, name: Test 0092 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0093-up, name: Test 0093 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0094-up, name: Test 0094 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0095-up, name: Test 0095 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0096-up, name: Test 0096 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0097-up, name: Test 0097 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0098-up, name: Test 0098 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0099-up, name: Test 0099 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0100-down, name: Test 0100 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0101-up, name: Test 0101 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0102-up, name: Test 0102 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0103-up, name: Test 0103 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0104-up, name: Test 0104 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0105-intermittent, name: Test 0105 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0106-up, name: Test 0106 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0107-up, name: Test 0107 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0108-up, name: Test 0108 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0109-up, name: Test 0109 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0110-down, name: Test 0110 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0111-up, name: Test 0111 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0112-up, name: Test 0112 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0113-up, name: Test 0113 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0114-up, name: Test 0114 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0115-up, name: Test 0115 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0116-up, name: Test 0116 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0117-up, name: Test 0117 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0118-up, name: Test 0118 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0119-up, name: Test 0119 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0120-intermittent, name: Test 0120 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0121-up, name: Test 0121 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0122-up, name: Test 0122 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0123-up, name: Test 0123 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0124-up, name: Test 0124 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0125-up, name: Test 0125 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0126-up, name: Test 0126 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0127-up, name: Test 0127 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0128-up, name: Test 0128 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0129-up, name: Test 0129 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0130-down, name: Test 0130 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0131-up, name: Test 0131 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0132-up, name: Test 0132 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0133-up, name: Test 0133 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0134-up, name: Test 0134 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0135-intermittent, name: Test 0135 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0136-up, name: Test 0136 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0137-up, name: Test 0137 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0138-up, name: Test 0138 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0139-up, name: Test 0139 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0140-down, name: Test 0140 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0141-up, name: Test 0141 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0142-up, name: Test 0142 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0143-up, name: Test 0143 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0144-up, name: Test 0144 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0145-up, name: Test 0145 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0146-up, name: Test 0146 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0147-up, name: Test 0147 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0148-up, name: Test 0148 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0149-up, name: Test 0149 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0150-intermittent, name: Test 0150 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0151-up, name: Test 0151 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0152-up, name: Test 0152 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0153-up, name: Test 0153 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0154-up, name: Test 0154 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0155-up, name: Test 0155 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0156-up, name: Test 0156 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0157-up, name: Test 0157 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0158-up, name: Test 0158 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0159-up, name: Test 0159 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0160-down, name: Test 0160 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0161-up, name: Test 0161 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0162-up, name: Test 0162 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0163-up, name: Test 0163 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0164-up, name: Test 0164 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0165-intermittent, name: Test 0165 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0166-up, name: Test 0166 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0167-up, name: Test 0167 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0168-up, name: Test 0168 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0169-up, name: Test 0169 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0170-down, name: Test 0170 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0171-up, name: Test 0171 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0172-up, name: Test 0172 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0173-up, name: Test 0173 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0174-up, name: Test 0174 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0175-up, name: Test 0175 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0176-up, name: Test 0176 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0177-up, name: Test 0177 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0178-up, name: Test 0178 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0179-up, name: Test 0179 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0180-intermittent, name: Test 0180 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0181-up, name: Test 0181 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0182-up, name: Test 0182 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0183-up, name: Test 0183 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0184-up, name: Test 0184 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0185-up, name: Test 0185 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0186-up, name: Test 0186 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0187-up, name: Test 0187 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0188-up, name: Test 0188 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0189-up, name: Test 0189 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0190-down, name: Test 0190 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0191-up, name: Test 0191 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0192-up, name: Test 0192 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0193-up, name: Test 0193 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0194-up, name: Test 0194 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0195-intermittent, name: Test 0195 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0196-up, name: Test 0196 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0197-up, name: Test 0197 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0198-up, name: Test 0198 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0199-up, name: Test 0199 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0200-down, name: Test 0200 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0201-up, name: Test 0201 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0202-up, name: Test 0202 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0203-up, name: Test 0203 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0204-up, name: Test 0204 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0205-up, name: Test 0205 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0206-up, name: Test 0206 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0207-up, name: Test 0207 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0208-up, name: Test 0208 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0209-up, name: Test 0209 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0210-intermittent, name: Test 0210 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0211-up, name: Test 0211 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0212-up, name: Test 0212 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0213-up, name: Test 0213 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0214-up, name: Test 0214 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0215-up, name: Test 0215 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0216-up, name: Test 0216 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0217-up, name: Test 0217 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0218-up, name: Test 0218 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0219-up, name: Test 0219 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0220-down, name: Test 0220 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0221-up, name: Test 0221 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0222-up, name: Test 0222 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0223-up, name: Test 0223 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0224-up, name: Test 0224 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0225-intermittent, name: Test 0225 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0226-up, name: Test 0226 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0227-up, name: Test 0227 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0228-up, name: Test 0228 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0229-up, name: Test 0229 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0230-down, name: Test 0230 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0231-up, name: Test 0231 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0232-up, name: Test 0232 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0233-up, name: Test 0233 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0234-up, name: Test 0234 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0235-up, name: Test 0235 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0236-up, name: Test 0236 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0237-up, name: Test 0237 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0238-up, name: Test 0238 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0239-up, name: Test 0239 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0240-intermittent, name: Test 0240 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0241-up, name: Test 0241 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0242-up, name: Test 0242 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0243-up, name: Test 0243 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0244-up, name: Test 0244 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0245-up, name: Test 0245 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0246-up, name: Test 0246 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0247-up, name: Test 0247 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0248-up, name: Test 0248 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0249-up, name: Test 0249 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0250-down, name: Test 0250 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0251-up, name: Test 0251 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0252-up, name: Test 0252 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0253-up, name: Test 0253 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0254-up, name: Test 0254 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0255-intermittent, name: Test 0255 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0256-up, name: Test 0256 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0257-up, name: Test 0257 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0258-up, name: Test 0258 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0259-up, name: Test 0259 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0260-down, name: Test 0260 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0261-up, name: Test 0261 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0262-up, name: Test 0262 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0263-up, name: Test 0263 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0264-up, name: Test 0264 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0265-up, name: Test 0265 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0266-up, name: Test 0266 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0267-up, name: Test 0267 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0268-up, name: Test 0268 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0269-up, name: Test 0269 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0270-intermittent, name: Test 0270 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0271-up, name: Test 0271 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0272-up, name: Test 0272 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0273-up, name: Test 0273 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0274-up, name: Test 0274 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0275-up, name: Test 0275 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0276-up, name: Test 0276 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0277-up, name: Test 0277 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0278-up, name: Test 0278 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0279-up, name: Test 0279 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0280-down, name: Test 0280 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0281-up, name: Test 0281 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0282-up, name: Test 0282 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0283-up, name: Test 0283 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0284-up, name: Test 0284 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0285-intermittent, name: Test 0285 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0286-up, name: Test 0286 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0287-up, name: Test 0287 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0288-up, name: Test 0288 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0289-up, name: Test 0289 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0290-down, name: Test 0290 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0291-up, name: Test 0291 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0292-up, name: Test 0292 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0293-up, name: Test 0293 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0294-up, name: Test 0294 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0295-up, name: Test 0295 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0296-up, name: Test 0296 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0297-up, name: Test 0297 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0298-up, name: Test 0298 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0299-up, name: Test 0299 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0300-intermittent, name: Test 0300 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0301-up, name: Test 0301 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0302-up, name: Test 0302 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0303-up, name: Test 0303 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0304-up, name: Test 0304 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0305-up, name: Test 0305 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0306-up, name: Test 0306 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0307-up, name: Test 0307 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0308-up, name: Test 0308 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0309-up, name: Test 0309 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0310-down, name: Test 0310 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0311-up, name: Test 0311 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0312-up, name: Test 0312 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0313-up, name: Test 0313 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0314-up, name: Test 0314 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0315-intermittent, name: Test 0315 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0316-up, name: Test 0316 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0317-up, name: Test 0317 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0318-up, name: Test 0318 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0319-up, name: Test 0319 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0320-down, name: Test 0320 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0321-up, name: Test 0321 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0322-up, name: Test 0322 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0323-up, name: Test 0323 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0324-up, name: Test 0324 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0325-up, name: Test 0325 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0326-up, name: Test 0326 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0327-up, name: Test 0327 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0328-up, name: Test 0328 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0329-up, name: Test 0329 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0330-intermittent, name: Test 0330 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0331-up, name: Test 0331 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0332-up, name: Test 0332 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0333-up, name: Test 0333 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0334-up, name: Test 0334 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0335-up, name: Test 0335 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0336-up, name: Test 0336 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0337-up, name: Test 0337 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0338-up, name: Test 0338 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0339-up, name: Test 0339 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0340-down, name: Test 0340 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0341-up, name: Test 0341 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0342-up, name: Test 0342 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0343-up, name: Test 0343 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0344-up, name: Test 0344 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0345-intermittent, name: Test 0345 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0346-up, name: Test 0346 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0347-up, name: Test 0347 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0348-up, name: Test 0348 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0349-up, name: Test 0349 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0350-down, name: Test 0350 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0351-up, name: Test 0351 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0352-up, name: Test 0352 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0353-up, name: Test 0353 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0354-up, name: Test 0354 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0355-up, name: Test 0355 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0356-up, name: Test 0356 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0357-up, name: Test 0357 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0358-up, name: Test 0358 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0359-up, name: Test 0359 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0360-intermittent, name: Test 0360 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0361-up, name: Test 0361 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0362-up, name: Test 0362 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0363-up, name: Test 0363 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0364-up, name: Test 0364 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0365-up, name: Test 0365 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0366-up, name: Test 0366 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0367-up, name: Test 0367 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0368-up, name: Test 0368 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0369-up, name: Test 0369 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0370-down, name: Test 0370 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0371-up, name: Test 0371 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0372-up, name: Test 0372 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0373-up, name: Test 0373 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0374-up, name: Test 0374 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0375-intermittent, name: Test 0375 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0376-up, name: Test 0376 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0377-up, name: Test 0377 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0378-up, name: Test 0378 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0379-up, name: Test 0379 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0380-down, name: Test 0380 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0381-up, name: Test 0381 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0382-up, name: Test 0382 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0383-up, name: Test 0383 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0384-up, name: Test 0384 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0385-up, name: Test 0385 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0386-up, name: Test 0386 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0387-up, name: Test 0387 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0388-up, name: Test 0388 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0389-up, name: Test 0389 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0390-intermittent, name: Test 0390 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0391-up, name: Test 0391 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0392-up, name: Test 0392 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0393-up, name: Test 0393 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0394-up, name: Test 0394 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0395-up, name: Test 0395 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0396-up, name: Test 0396 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0397-up, name: Test 0397 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0398-up, name: Test 0398 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0399-up, name: Test 0399 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0400-down, name: Test 0400 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0401-up, name: Test 0401 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0402-up, name: Test 0402 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0403-up, name: Test 0403 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0404-up, name: Test 0404 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0405-intermittent, name: Test 0405 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0406-up, name: Test 0406 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0407-up, name: Test 0407 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0408-up, name: Test 0408 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0409-up, name: Test 0409 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0410-down, name: Test 0410 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0411-up, name: Test 0411 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0412-up, name: Test 0412 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0413-up, name: Test 0413 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0414-up, name: Test 0414 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0415-up, name: Test 0415 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0416-up, name: Test 0416 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0417-up, name: Test 0417 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0418-up, name: Test 0418 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0419-up, name: Test 0419 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0420-intermittent, name: Test 0420 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0421-up, name: Test 0421 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0422-up, name: Test 0422 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0423-up, name: Test 0423 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0424-up, name: Test 0424 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0425-up, name: Test 0425 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0426-up, name: Test 0426 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0427-up, name: Test 0427 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0428-up, name: Test 0428 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0429-up, name: Test 0429 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0430-down, name: Test 0430 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0431-up, name: Test 0431 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0432-up, name: Test 0432 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0433-up, name: Test 0433 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0434-up, name: Test 0434 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0435-intermittent, name: Test 0435 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0436-up, name: Test 0436 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0437-up, name: Test 0437 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0438-up, name: Test 0438 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0439-up, name: Test 0439 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0440-down, name: Test 0440 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0441-up, name: Test 0441 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0442-up, name: Test 0442 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0443-up, name: Test 0443 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0444-up, name: Test 0444 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0445-up, name: Test 0445 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0446-up, name: Test 0446 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0447-up, name: Test 0447 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0448-up, name: Test 0448 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0449-up, name: Test 0449 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0450-intermittent, name: Test 0450 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0451-up, name: Test 0451 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0452-up, name: Test 0452 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0453-up, name: Test 0453 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0454-up, name: Test 0454 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0455-up, name: Test 0455 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0456-up, name: Test 0456 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0457-up, name: Test 0457 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0458-up, name: Test 0458 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0459-up, name: Test 0459 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0460-down, name: Test 0460 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0461-up, name: Test 0461 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0462-up, name: Test 0462 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0463-up, name: Test 0463 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0464-up, name: Test 0464 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0465-intermittent, name: Test 0465 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0466-up, name: Test 0466 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0467-up, name: Test 0467 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0468-up, name: Test 0468 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0469-up, name: Test 0469 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0470-down, name: Test 0470 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0471-up, name: Test 0471 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0472-up, name: Test 0472 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0473-up, name: Test 0473 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0474-up, name: Test 0474 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0475-up, name: Test 0475 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0476-up, name: Test 0476 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0477-up, name: Test 0477 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0478-up, name: Test 0478 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0479-up, name: Test 0479 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0480-intermittent, name: Test 0480 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0481-up, name: Test 0481 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0482-up, name: Test 0482 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0483-up, name: Test 0483 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0484-up, name: Test 0484 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0485-up, name: Test 0485 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0486-up, name: Test 0486 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0487-up, name: Test 0487 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0488-up, name: Test 0488 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0489-up, name: Test 0489 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0490-down, name: Test 0490 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0491-up, name: Test 0491 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0492-up, name: Test 0492 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0493-up, name: Test 0493 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0494-up, name: Test 0494 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0495-intermittent, name: Test 0495 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0496-up, name: Test 0496 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0497-up, name: Test 0497 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0498-up, name: Test 0498 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0499-up, name: Test 0499 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0500-down, name: Test 0500 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0501-up, name: Test 0501 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0502-up, name: Test 0502 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0503-up, name: Test 0503 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0504-up, name: Test 0504 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0505-up, name: Test 0505 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0506-up, name: Test 0506 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0507-up, name: Test 0507 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0508-up, name: Test 0508 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0509-up, name: Test 0509 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0510-intermittent, name: Test 0510 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0511-up, name: Test 0511 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0512-up, name: Test 0512 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0513-up, name: Test 0513 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0514-up, name: Test 0514 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0515-up, name: Test 0515 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0516-up, name: Test 0516 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0517-up, name: Test 0517 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0518-up, name: Test 0518 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0519-up, name: Test 0519 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0520-down, name: Test 0520 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0521-up, name: Test 0521 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0522-up, name: Test 0522 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0523-up, name: Test 0523 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0524-up, name: Test 0524 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0525-intermittent, name: Test 0525 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0526-up, name: Test 0526 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0527-up, name: Test 0527 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0528-up, name: Test 0528 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0529-up, name: Test 0529 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0530-down, name: Test 0530 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0531-up, name: Test 0531 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0532-up, name: Test 0532 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0533-up, name: Test 0533 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0534-up, name: Test 0534 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0535-up, name: Test 0535 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0536-up, name: Test 0536 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0537-up, name: Test 0537 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0538-up, name: Test 0538 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0539-up, name: Test 0539 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0540-intermittent, name: Test 0540 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0541-up, name: Test 0541 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0542-up, name: Test 0542 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0543-up, name: Test 0543 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0544-up, name: Test 0544 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0545-up, name: Test 0545 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0546-up, name: Test 0546 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0547-up, name: Test 0547 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0548-up, name: Test 0548 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0549-up, name: Test 0549 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0550-down, name: Test 0550 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0551-up, name: Test 0551 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0552-up, name: Test 0552 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0553-up, name: Test 0553 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0554-up, name: Test 0554 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0555-intermittent, name: Test 0555 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0556-up, name: Test 0556 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0557-up, name: Test 0557 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0558-up, name: Test 0558 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0559-up, name: Test 0559 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0560-down, name: Test 0560 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0561-up, name: Test 0561 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0562-up, name: Test 0562 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0563-up, name: Test 0563 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0564-up, name: Test 0564 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0565-up, name: Test 0565 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0566-up, name: Test 0566 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0567-up, name: Test 0567 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0568-up, name: Test 0568 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0569-up, name: Test 0569 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0570-intermittent, name: Test 0570 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0571-up, name: Test 0571 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0572-up, name: Test 0572 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0573-up, name: Test 0573 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0574-up, name: Test 0574 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0575-up, name: Test 0575 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0576-up, name: Test 0576 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0577-up, name: Test 0577 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0578-up, name: Test 0578 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0579-up, name: Test 0579 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0580-down, name: Test 0580 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0581-up, name: Test 0581 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0582-up, name: Test 0582 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0583-up, name: Test 0583 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0584-up, name: Test 0584 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0585-intermittent, name: Test 0585 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0586-up, name: Test 0586 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0587-up, name: Test 0587 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0588-up, name: Test 0588 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0589-up, name: Test 0589 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0590-down, name: Test 0590 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0591-up, name: Test 0591 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0592-up, name: Test 0592 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0593-up, name: Test 0593 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0594-up, name: Test 0594 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0595-up, name: Test 0595 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0596-up, name: Test 0596 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0597-up, name: Test 0597 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0598-up, name: Test 0598 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0599-up, name: Test 0599 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0600-intermittent, name: Test 0600 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0601-up, name: Test 0601 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0602-up, name: Test 0602 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0603-up, name: Test 0603 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0604-up, name: Test 0604 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0605-up, name: Test 0605 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0606-up, name: Test 0606 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0607-up, name: Test 0607 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0608-up, name: Test 0608 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0609-up, name: Test 0609 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0610-down, name: Test 0610 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0611-up, name: Test 0611 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0612-up, name: Test 0612 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0613-up, name: Test 0613 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0614-up, name: Test 0614 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0615-intermittent, name: Test 0615 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0616-up, name: Test 0616 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0617-up, name: Test 0617 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0618-up, name: Test 0618 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0619-up, name: Test 0619 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0620-down, name: Test 0620 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0621-up, name: Test 0621 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0622-up, name: Test 0622 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0623-up, name: Test 0623 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0624-up, name: Test 0624 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0625-up, name: Test 0625 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0626-up, name: Test 0626 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0627-up, name: Test 0627 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0628-up, name: Test 0628 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0629-up, name: Test 0629 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0630-intermittent, name: Test 0630 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0631-up, name: Test 0631 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0632-up, name: Test 0632 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0633-up, name: Test 0633 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0634-up, name: Test 0634 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0635-up, name: Test 0635 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0636-up, name: Test 0636 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0637-up, name: Test 0637 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0638-up, name: Test 0638 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0639-up, name: Test 0639 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0640-down, name: Test 0640 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0641-up, name: Test 0641 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0642-up, name: Test 0642 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0643-up, name: Test 0643 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0644-up, name: Test 0644 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0645-intermittent, name: Test 0645 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0646-up, name: Test 0646 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0647-up, name: Test 0647 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0648-up, name: Test 0648 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0649-up, name: Test 0649 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0650-down, name: Test 0650 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0651-up, name: Test 0651 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0652-up, name: Test 0652 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0653-up, name: Test 0653 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0654-up, name: Test 0654 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0655-up, name: Test 0655 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0656-up, name: Test 0656 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0657-up, name: Test 0657 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0658-up, name: Test 0658 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0659-up, name: Test 0659 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0660-intermittent, name: Test 0660 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0661-up, name: Test 0661 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0662-up, name: Test 0662 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0663-up, name: Test 0663 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0664-up, name: Test 0664 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0665-up, name: Test 0665 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0666-up, name: Test 0666 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0667-up, name: Test 0667 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0668-up, name: Test 0668 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0669-up, name: Test 0669 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0670-down, name: Test 0670 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0671-up, name: Test 0671 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0672-up, name: Test 0672 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0673-up, name: Test 0673 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0674-up, name: Test 0674 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0675-intermittent, name: Test 0675 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0676-up, name: Test 0676 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0677-up, name: Test 0677 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0678-up, name: Test 0678 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0679-up, name: Test 0679 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0680-down, name: Test 0680 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0681-up, name: Test 0681 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0682-up, name: Test 0682 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0683-up, name: Test 0683 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0684-up, name: Test 0684 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0685-up, name: Test 0685 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0686-up, name: Test 0686 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0687-up, name: Test 0687 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0688-up, name: Test 0688 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0689-up, name: Test 0689 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0690-intermittent, name: Test 0690 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0691-up, name: Test 0691 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0692-up, name: Test 0692 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0693-up, name: Test 0693 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0694-up, name: Test 0694 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0695-up, name: Test 0695 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0696-up, name: Test 0696 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0697-up, name: Test 0697 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0698-up, name: Test 0698 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0699-up, name: Test 0699 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0700-down, name: Test 0700 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0701-up, name: Test 0701 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0702-up, name: Test 0702 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0703-up, name: Test 0703 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0704-up, name: Test 0704 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0705-intermittent, name: Test 0705 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0706-up, name: Test 0706 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0707-up, name: Test 0707 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0708-up, name: Test 0708 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0709-up, name: Test 0709 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0710-down, name: Test 0710 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0711-up, name: Test 0711 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0712-up, name: Test 0712 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0713-up, name: Test 0713 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0714-up, name: Test 0714 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0715-up, name: Test 0715 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0716-up, name: Test 0716 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0717-up, name: Test 0717 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0718-up, name: Test 0718 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0719-up, name: Test 0719 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0720-intermittent, name: Test 0720 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0721-up, name: Test 0721 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0722-up, name: Test 0722 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0723-up, name: Test 0723 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0724-up, name: Test 0724 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0725-up, name: Test 0725 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0726-up, name: Test 0726 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0727-up, name: Test 0727 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0728-up, name: Test 0728 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0729-up, name: Test 0729 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0730-down, name: Test 0730 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0731-up, name: Test 0731 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0732-up, name: Test 0732 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0733-up, name: Test 0733 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0734-up, name: Test 0734 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0735-intermittent, name: Test 0735 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0736-up, name: Test 0736 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0737-up, name: Test 0737 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0738-up, name: Test 0738 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0739-up, name: Test 0739 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0740-down, name: Test 0740 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0741-up, name: Test 0741 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0742-up, name: Test 0742 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0743-up, name: Test 0743 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0744-up, name: Test 0744 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0745-up, name: Test 0745 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0746-up, name: Test 0746 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0747-up, name: Test 0747 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0748-up, name: Test 0748 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0749-up, name: Test 0749 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0750-intermittent, name: Test 0750 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0751-up, name: Test 0751 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0752-up, name: Test 0752 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0753-up, name: Test 0753 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0754-up, name: Test 0754 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0755-up, name: Test 0755 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0756-up, name: Test 0756 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0757-up, name: Test 0757 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0758-up, name: Test 0758 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0759-up, name: Test 0759 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0760-down, name: Test 0760 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0761-up, name: Test 0761 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0762-up, name: Test 0762 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0763-up, name: Test 0763 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0764-up, name: Test 0764 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0765-intermittent, name: Test 0765 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0766-up, name: Test 0766 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0767-up, name: Test 0767 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0768-up, name: Test 0768 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0769-up, name: Test 0769 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0770-down, name: Test 0770 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0771-up, name: Test 0771 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0772-up, name: Test 0772 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0773-up, name: Test 0773 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0774-up, name: Test 0774 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0775-up, name: Test 0775 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0776-up, name: Test 0776 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0777-up, name: Test 0777 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0778-up, name: Test 0778 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0779-up, name: Test 0779 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0780-intermittent, name: Test 0780 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0781-up, name: Test 0781 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0782-up, name: Test 0782 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0783-up, name: Test 0783 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0784-up, name: Test 0784 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0785-up, name: Test 0785 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0786-up, name: Test 0786 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0787-up, name: Test 0787 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0788-up, name: Test 0788 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0789-up, name: Test 0789 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0790-down, name: Test 0790 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0791-up, name: Test 0791 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0792-up, name: Test 0792 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0793-up, name: Test 0793 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0794-up, name: Test 0794 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0795-intermittent, name: Test 0795 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0796-up, name: Test 0796 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0797-up, name: Test 0797 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0798-up, name: Test 0798 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0799-up, name: Test 0799 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0800-down, name: Test 0800 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0801-up, name: Test 0801 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0802-up, name: Test 0802 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0803-up, name: Test 0803 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0804-up, name: Test 0804 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0805-up, name: Test 0805 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0806-up, name: Test 0806 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0807-up, name: Test 0807 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0808-up, name: Test 0808 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0809-up, name: Test 0809 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0810-intermittent, name: Test 0810 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0811-up, name: Test 0811 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0812-up, name: Test 0812 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0813-up, name: Test 0813 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0814-up, name: Test 0814 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0815-up, name: Test 0815 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0816-up, name: Test 0816 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0817-up, name: Test 0817 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0818-up, name: Test 0818 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0819-up, name: Test 0819 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0820-down, name: Test 0820 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0821-up, name: Test 0821 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0822-up, name: Test 0822 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0823-up, name: Test 0823 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0824-up, name: Test 0824 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0825-intermittent, name: Test 0825 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0826-up, name: Test 0826 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0827-up, name: Test 0827 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0828-up, name: Test 0828 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0829-up, name: Test 0829 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0830-down, name: Test 0830 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0831-up, name: Test 0831 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0832-up, name: Test 0832 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0833-up, name: Test 0833 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0834-up, name: Test 0834 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0835-up, name: Test 0835 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0836-up, name: Test 0836 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0837-up, name: Test 0837 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0838-up, name: Test 0838 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0839-up, name: Test 0839 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0840-intermittent, name: Test 0840 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0841-up, name: Test 0841 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0842-up, name: Test 0842 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0843-up, name: Test 0843 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0844-up, name: Test 0844 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0845-up, name: Test 0845 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0846-up, name: Test 0846 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0847-up, name: Test 0847 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0848-up, name: Test 0848 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0849-up, name: Test 0849 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0850-down, name: Test 0850 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0851-up, name: Test 0851 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0852-up, name: Test 0852 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0853-up, name: Test 0853 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0854-up, name: Test 0854 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0855-intermittent, name: Test 0855 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0856-up, name: Test 0856 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0857-up, name: Test 0857 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0858-up, name: Test 0858 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0859-up, name: Test 0859 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0860-down, name: Test 0860 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0861-up, name: Test 0861 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0862-up, name: Test 0862 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0863-up, name: Test 0863 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0864-up, name: Test 0864 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0865-up, name: Test 0865 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0866-up, name: Test 0866 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0867-up, name: Test 0867 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0868-up, name: Test 0868 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0869-up, name: Test 0869 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0870-intermittent, name: Test 0870 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0871-up, name: Test 0871 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0872-up, name: Test 0872 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0873-up, name: Test 0873 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0874-up, name: Test 0874 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0875-up, name: Test 0875 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0876-up, name: Test 0876 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0877-up, name: Test 0877 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0878-up, name: Test 0878 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0879-up, name: Test 0879 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0880-down, name: Test 0880 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0881-up, name: Test 0881 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0882-up, name: Test 0882 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0883-up, name: Test 0883 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0884-up, name: Test 0884 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0885-intermittent, name: Test 0885 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0886-up, name: Test 0886 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0887-up, name: Test 0887 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0888-up, name: Test 0888 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0889-up, name: Test 0889 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0890-down, name: Test 0890 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0891-up, name: Test 0891 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0892-up, name: Test 0892 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0893-up, name: Test 0893 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0894-up, name: Test 0894 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0895-up, name: Test 0895 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0896-up, name: Test 0896 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0897-up, name: Test 0897 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0898-up, name: Test 0898 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0899-up, name: Test 0899 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0900-intermittent, name: Test 0900 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0901-up, name: Test 0901 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0902-up, name: Test 0902 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0903-up, name: Test 0903 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0904-up, name: Test 0904 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0905-up, name: Test 0905 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0906-up, name: Test 0906 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0907-up, name: Test 0907 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0908-up, name: Test 0908 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0909-up, name: Test 0909 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0910-down, name: Test 0910 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0911-up, name: Test 0911 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0912-up, name: Test 0912 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0913-up, name: Test 0913 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0914-up, name: Test 0914 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0915-intermittent, name: Test 0915 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0916-up, name: Test 0916 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0917-up, name: Test 0917 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0918-up, name: Test 0918 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0919-up, name: Test 0919 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0920-down, name: Test 0920 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0921-up, name: Test 0921 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0922-up, name: Test 0922 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0923-up, name: Test 0923 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0924-up, name: Test 0924 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0925-up, name: Test 0925 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0926-up, name: Test 0926 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0927-up, name: Test 0927 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0928-up, name: Test 0928 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0929-up, name: Test 0929 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0930-intermittent, name: Test 0930 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0931-up, name: Test 0931 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0932-up, name: Test 0932 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0933-up, name: Test 0933 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0934-up, name: Test 0934 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0935-up, name: Test 0935 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0936-up, name: Test 0936 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0937-up, name: Test 0937 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0938-up, name: Test 0938 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0939-up, name: Test 0939 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0940-down, name: Test 0940 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0941-up, name: Test 0941 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0942-up, name: Test 0942 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0943-up, name: Test 0943 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0944-up, name: Test 0944 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0945-intermittent, name: Test 0945 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0946-up, name: Test 0946 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0947-up, name: Test 0947 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0948-up, name: Test 0948 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0949-up, name: Test 0949 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0950-down, name: Test 0950 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0951-up, name: Test 0951 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0952-up, name: Test 0952 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0953-up, name: Test 0953 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0954-up, name: Test 0954 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0955-up, name: Test 0955 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0956-up, name: Test 0956 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0957-up, name: Test 0957 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0958-up, name: Test 0958 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0959-up, name: Test 0959 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0960-intermittent, name: Test 0960 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0961-up, name: Test 0961 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0962-up, name: Test 0962 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0963-up, name: Test 0963 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0964-up, name: Test 0964 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0965-up, name: Test 0965 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0966-up, name: Test 0966 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0967-up, name: Test 0967 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0968-up, name: Test 0968 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0969-up, name: Test 0969 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0970-down, name: Test 0970 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0971-up, name: Test 0971 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0972-up, name: Test 0972 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0973-up, name: Test 0973 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0974-up, name: Test 0974 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0975-intermittent, name: Test 0975 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0976-up, name: Test 0976 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0977-up, name: Test 0977 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0978-up, name: Test 0978 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0979-up, name: Test 0979 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0980-down, name: Test 0980 - down, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=400x1'} +- {id: 0981-up, name: Test 0981 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0982-up, name: Test 0982 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0983-up, name: Test 0983 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0984-up, name: Test 0984 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0985-up, name: Test 0985 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0986-up, name: Test 0986 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0987-up, name: Test 0987 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0988-up, name: Test 0988 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0989-up, name: Test 0989 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0990-intermittent, name: Test 0990 - intermittent, schedule: '@every 30s', + timeout: 1s, type: http, urls: 'http://localhost:5678/pattern?r=200x5,500x1'} +- {id: 0991-up, name: Test 0991 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0992-up, name: Test 0992 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0993-up, name: Test 0993 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0994-up, name: Test 0994 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0995-up, name: Test 0995 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0996-up, name: Test 0996 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0997-up, name: Test 0997 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0998-up, name: Test 0998 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} +- {id: 0999-up, name: Test 0999 - up, schedule: '@every 30s', timeout: 1s, type: http, + urls: 'http://localhost:5678/pattern?r=200x1'} output.elasticsearch: - # Array of hosts to connect to. - hosts: ["localhost:9200"] - - # Optional protocol and basic auth credentials. - #protocol: "https" - #username: "elastic" - #password: "changeme" - -#----------------------------- Logstash output -------------------------------- -#output.logstash: - # The Logstash hosts - #hosts: ["localhost:5044"] - - # Optional SSL. By default is off. - # List of root certificates for HTTPS server verifications - #ssl.certificate_authorities: ["/etc/pki/root/ca.pem"] - - # Certificate for SSL client authentication - #ssl.certificate: "/etc/pki/client/cert.pem" - - # Client Certificate Key - #ssl.key: "/etc/pki/client/cert.key" - -#================================ Processors ===================================== - + hosts: ['localhost:9200'] processors: - - add_observer_metadata: - # Optional, but recommended geo settings for the location Heartbeat is running in - #geo: - # Token describing this location - #name: us-east-1a - - # Lat, Lon " - #location: "37.926868, -78.024902" - -#================================ Logging ===================================== - -# Sets log level. The default log level is info. -# Available log levels are: error, warning, info, debug -#logging.level: debug - -# At debug level, you can selectively enable logging only for some components. -# To enable all selectors use ["*"]. Examples of other selectors are "beat", -# "publish", "service". -#logging.selectors: ["*"] - -#============================== X-Pack Monitoring =============================== -# heartbeat can export internal metrics to a central Elasticsearch monitoring -# cluster. This requires xpack monitoring to be enabled in Elasticsearch. The -# reporting is disabled by default. - -# Set to true to enable the monitoring reporter. -#monitoring.enabled: false - -# Sets the UUID of the Elasticsearch cluster under which monitoring data for this -# Heartbeat instance will appear in the Stack Monitoring UI. If output.elasticsearch -# is enabled, the UUID is derived from the Elasticsearch cluster referenced by output.elasticsearch. -#monitoring.cluster_uuid: - -# Uncomment to send the metrics to Elasticsearch. Most settings from the -# Elasticsearch output are accepted here as well. -# Note that the settings should point to your Elasticsearch *monitoring* cluster. -# Any setting that is not set is automatically inherited from the Elasticsearch -# output configuration, so if you have the Elasticsearch output configured such -# that it is pointing to your Elasticsearch monitoring cluster, you can simply -# uncomment the following line. -#monitoring.elasticsearch: - -#================================= Migration ================================== +- add_observer_metadata: + geo: {location: '37.926868, -78.024902', name: '${GEO_NAME}'} -# This allows to enable 6.7 migration aliases -#migration.6_to_7.enabled: true diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 8cbc2a929d98..14b6a686ff87 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/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 1f23c1f8d5a8..165c42e480f9 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -22,18 +22,17 @@ import ( "sync" "time" - "github.com/elastic/beats/heartbeat/scheduler" - - "github.com/gofrs/uuid" - "github.com/mitchellh/hashstructure" - "github.com/pkg/errors" - "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/look" "github.com/elastic/beats/heartbeat/monitors/jobs" + "github.com/elastic/beats/heartbeat/scheduler" + "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/libbeat/logp" + "github.com/gofrs/uuid" + "github.com/mitchellh/hashstructure" + "github.com/pkg/errors" ) // WrapCommon applies the common wrappers that all monitor jobs get. @@ -51,7 +50,7 @@ func WrapCommon(js []jobs.Job, id string, name string, typ string, schedule sche } // addMonitorMeta adds the id, name, and type fields to the monitor. -func addMonitorMeta(id string, name string, typ string, isMulti bool, schedule scheduler.Schedule) jobs.JobWrapper { +func addMonitorMeta(id string, name string, typ string, isMulti bool, sched scheduler.Schedule) jobs.JobWrapper { return func(job jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { cont, e := job(event) @@ -68,7 +67,17 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool, schedule s } now := time.Now() - nextRun := schedule.Next(now) + nextRun := sched.Next(now) + + var quantizedRangeStart time.Time + + if isched, ok := sched.(schedule.IntervalScheduler); ok { + quantizedRangeStart, _ = isched.QuantizedPeriod(now) + } else { + // TODO actually calculate the correct start time accurately for cron. + quantizedRangeStart = now + } + eventext.MergeEventFields( event, common.MapStr{ @@ -78,6 +87,14 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool, schedule s "type": typ, "next_run": nextRun, "next_run_in": common.MapStr{"us": nextRun.Sub(now)}, + "quantized_range": common.MapStr{ + "gte": quantizedRangeStart, + "lt": nextRun, + }, + "quantized_grace_range": common.MapStr{ + "gte": quantizedRangeStart, + "lt": sched.Next(nextRun), + }, }, }, ) diff --git a/heartbeat/scheduler/schedule/quantize/quantize.go b/heartbeat/scheduler/schedule/quantize/quantize.go index d3912b6384a0..7b985a319876 100644 --- a/heartbeat/scheduler/schedule/quantize/quantize.go +++ b/heartbeat/scheduler/schedule/quantize/quantize.go @@ -1 +1,10 @@ package quantize + +import "time" + +func Quantize(t time.Time, period time.Duration) (start time.Time, end time.Time) { + periodUnix := time.Unix(int64(period/time.Second), 0).Unix() + start = time.Unix((t.Unix()/periodUnix)*periodUnix, 0) + end = start.Add(period) + return start, end +} diff --git a/heartbeat/scheduler/schedule/schedule.go b/heartbeat/scheduler/schedule/schedule.go index 737c6468bf02..83ec8cfc5e65 100644 --- a/heartbeat/scheduler/schedule/schedule.go +++ b/heartbeat/scheduler/schedule/schedule.go @@ -21,6 +21,8 @@ import ( "strings" "time" + "github.com/elastic/beats/heartbeat/scheduler/schedule/quantize" + "github.com/elastic/beats/heartbeat/scheduler" "github.com/elastic/beats/heartbeat/scheduler/schedule/cron" ) @@ -29,10 +31,14 @@ type Schedule struct { scheduler.Schedule } -type intervalScheduler struct { +type IntervalScheduler struct { interval time.Duration } +func (s IntervalScheduler) QuantizedPeriod(now time.Time) (gte time.Time, lt time.Time) { + return quantize.Quantize(now, s.interval) +} + func Parse(in string) (*Schedule, error) { every := "@every" @@ -44,7 +50,7 @@ func Parse(in string) (*Schedule, error) { return nil, err } - return &Schedule{intervalScheduler{d}}, nil + return &Schedule{IntervalScheduler{d}}, nil } // fallback on cron scheduler parsers @@ -55,7 +61,7 @@ func Parse(in string) (*Schedule, error) { return &Schedule{s}, nil } -func (s intervalScheduler) Next(t time.Time) time.Time { +func (s IntervalScheduler) Next(t time.Time) time.Time { return t.Add(s.interval) } diff --git a/heartbeat/scheduler/schedule/schedule_test.go b/heartbeat/scheduler/schedule/schedule_test.go index 2d0bed8d8362..50290ef3c0ee 100644 --- a/heartbeat/scheduler/schedule/schedule_test.go +++ b/heartbeat/scheduler/schedule/schedule_test.go @@ -36,13 +36,13 @@ func TestParse(t *testing.T) { { "every second", "@every 1s", - &Schedule{intervalScheduler{time.Duration(1 * time.Second)}}, + &Schedule{IntervalScheduler{time.Duration(1 * time.Second)}}, false, }, { "every year", "@every 1m", - &Schedule{intervalScheduler{time.Duration(1 * time.Minute)}}, + &Schedule{IntervalScheduler{time.Duration(1 * time.Minute)}}, false, }, { @@ -88,24 +88,24 @@ func Test_intervalScheduler_Next(t *testing.T) { tests := []struct { name string - s intervalScheduler + s IntervalScheduler want time.Time }{ { "one second", - intervalScheduler{time.Duration(time.Second)}, + IntervalScheduler{time.Duration(time.Second)}, now.Add(time.Second), }, { "one minute", - intervalScheduler{time.Duration(time.Minute)}, + IntervalScheduler{time.Duration(time.Minute)}, now.Add(time.Minute), }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := tt.s.Next(now); !reflect.DeepEqual(got, tt.want) { - t.Errorf("intervalScheduler.Next() = %v, want %v", got, tt.want) + t.Errorf("IntervalScheduler.Next() = %v, want %v", got, tt.want) } }) } @@ -121,30 +121,30 @@ func TestSchedule_Unpack(t *testing.T) { }{ { "one minute -> one second", - &Schedule{intervalScheduler{time.Minute}}, + &Schedule{IntervalScheduler{time.Minute}}, "@every 1s", - intervalScheduler{time.Second}, + IntervalScheduler{time.Second}, false, }, { "every 15 cron -> every second interval", &Schedule{cron.MustParse("*/15 * * * *")}, "@every 1s", - intervalScheduler{time.Second}, + IntervalScheduler{time.Second}, false, }, { "every second interval -> every 15 cron", - &Schedule{intervalScheduler{time.Second}}, + &Schedule{IntervalScheduler{time.Second}}, "*/15 * * * *", cron.MustParse("*/15 * * * *"), false, }, { "bad format", - &Schedule{intervalScheduler{time.Minute}}, + &Schedule{IntervalScheduler{time.Minute}}, "foobar", - intervalScheduler{time.Minute}, + IntervalScheduler{time.Minute}, true, }, } diff --git a/libbeat/mapping/field.go b/libbeat/mapping/field.go index 0dabe3f340a5..4769f34ea063 100644 --- a/libbeat/mapping/field.go +++ b/libbeat/mapping/field.go @@ -131,6 +131,8 @@ func (f *Field) validateType() error { return dateType.validate(f.Format) case "geo_point": return geoPointType.validate(f.Format) + case "date_range": + return dateRangeType.validate(f.Format) case "boolean", "binary", "ip", "alias", "array": if f.Format != "" { return fmt.Errorf("no format expected for field %s, found: %s", f.Name, f.Format) @@ -157,10 +159,11 @@ type fieldTypeGroup struct { } var ( - stringType = fieldTypeGroup{"string", []string{"string", "url"}} - numberType = fieldTypeGroup{"number", []string{"string", "url", "bytes", "duration", "number", "percent", "color"}} - dateType = fieldTypeGroup{"date", []string{"string", "url", "date"}} - geoPointType = fieldTypeGroup{"geo_point", []string{"geo_point"}} + stringType = fieldTypeGroup{"string", []string{"string", "url"}} + numberType = fieldTypeGroup{"number", []string{"string", "url", "bytes", "duration", "number", "percent", "color"}} + dateType = fieldTypeGroup{"date", []string{"string", "url", "date"}} + geoPointType = fieldTypeGroup{"geo_point", []string{"geo_point"}} + dateRangeType = fieldTypeGroup{"date_range", []string{"date_range"}} ) func (g *fieldTypeGroup) validate(formatter string) error { From a371f6e424233a4b253a820c32c673be1b213350 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 25 Nov 2019 19:49:30 -0600 Subject: [PATCH 010/102] Just report the timespan --- heartbeat/_meta/fields.common.yml | 25 ++-------------- heartbeat/hbtest/hbtestutil.go | 4 +-- heartbeat/hbtestllext/validators.go | 11 +++---- heartbeat/monitors/active/http/http_test.go | 6 ++-- heartbeat/monitors/mocks_test.go | 2 +- heartbeat/monitors/wrappers/monitors.go | 30 +++++-------------- heartbeat/monitors/wrappers/monitors_test.go | 10 +++---- .../scheduler/schedule/quantize/quantize.go | 10 ------- heartbeat/scheduler/schedule/schedule.go | 6 ---- 9 files changed, 25 insertions(+), 79 deletions(-) delete mode 100644 heartbeat/scheduler/schedule/quantize/quantize.go diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 2e1cc73a12f1..28a721494f9a 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -63,31 +63,10 @@ description: > A token unique to a simultaneously invoked group of checks as in the case where multiple IPs are checked for a single DNS entry. - - name: quantized_range + - name: timespan type: date_range description: > - Time range this ping reported on quantized based on timestamp - - - name: quantized_grace_range - type: date_range - description: > - Same as start time as quantized range but twice as long. This should overlap with the next check. - Useful in queries where you want the latest value. - - - name: next_run - type: date - description: > - The next expected time this monitor will run on the reporting heartbeat agent based on its schedule. - It may run sooner than this if the heartbeat daemon is restarted, - and it may run later than this time for any number of reasons - - name: next_run_in - type: group - description: Duration between when this run occurred and when the next one is expected. - fields: - - name: us - type: long - description: Duration between when this run occurred and when the next one is expected in microseconds. - + Time range this ping reported starting at the instant the check was started, ending at the start of the next scheduled check. - key: summary title: "Monitor summary" diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index bc7e62f0fda7..8bbb2476ddf7 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -114,15 +114,15 @@ func BaseChecks(ip string, status string, typ string) validator.Validator { lookslike.MustCompile(map[string]interface{}{ "monitor": map[string]interface{}{ "ip": ipCheck, - "duration.us": isdef.IsDuration, "status": status, + "duration.us": isdef.IsDuration, "id": isdef.IsNonEmptyString, "name": isdef.IsString, "type": typ, "check_group": isdef.IsString, }, }), - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, ) } diff --git a/heartbeat/hbtestllext/validators.go b/heartbeat/hbtestllext/validators.go index 7c19b37a753f..23a9df5d5cf2 100644 --- a/heartbeat/hbtestllext/validators.go +++ b/heartbeat/hbtestllext/validators.go @@ -19,13 +19,14 @@ package hbtestllext import ( "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/isdef" ) -// MonitorNextRunValidator is tests for the `next_run` and `next_run_in.us` keys. -var MonitorNextRunValidator = lookslike.MustCompile(map[string]interface{}{ +// MonitorTimespanValidator is tests for the `next_run` and `next_run_in.us` keys. +var MonitorTimespanValidator = lookslike.MustCompile(map[string]interface{}{ "monitor": map[string]interface{}{ - "next_run": IsTime, - "next_run_in.us": isdef.IsDuration, + "timespan": map[string]interface{}{ + "gte": IsTime, + "lt": IsTime, + }, }, }) diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 43d2de34a104..0d65284a2894 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -31,12 +31,9 @@ import ( "testing" "time" - schedule "github.com/elastic/beats/heartbeat/scheduler/schedule" - - "github.com/stretchr/testify/require" - "github.com/elastic/beats/heartbeat/hbtest" "github.com/elastic/beats/heartbeat/monitors/wrappers" + schedule "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/libbeat/common/file" @@ -47,6 +44,7 @@ import ( "github.com/elastic/go-lookslike/llresult" "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" + "github.com/stretchr/testify/require" ) func testRequest(t *testing.T, testURL string) *beat.Event { diff --git a/heartbeat/monitors/mocks_test.go b/heartbeat/monitors/mocks_test.go index 642f0d1ae0e3..4af7878b38a3 100644 --- a/heartbeat/monitors/mocks_test.go +++ b/heartbeat/monitors/mocks_test.go @@ -118,7 +118,7 @@ func mockEventMonitorValidator(id string) validator.Validator { "check_group": isdef.IsString, }, }), - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, hbtest.SummaryChecks(1, 0), lookslike.MustCompile(mockEventCustomFields()), )) diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 165c42e480f9..83ae6b73c12f 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -26,7 +26,6 @@ import ( "github.com/elastic/beats/heartbeat/look" "github.com/elastic/beats/heartbeat/monitors/jobs" "github.com/elastic/beats/heartbeat/scheduler" - "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/libbeat/logp" @@ -53,6 +52,7 @@ func WrapCommon(js []jobs.Job, id string, name string, typ string, schedule sche func addMonitorMeta(id string, name string, typ string, isMulti bool, sched scheduler.Schedule) jobs.JobWrapper { return func(job jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { + started := time.Now() cont, e := job(event) thisID := id @@ -66,35 +66,19 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool, sched sche thisID = fmt.Sprintf("%s-%x", id, urlHash) } - now := time.Now() - nextRun := sched.Next(now) - - var quantizedRangeStart time.Time - - if isched, ok := sched.(schedule.IntervalScheduler); ok { - quantizedRangeStart, _ = isched.QuantizedPeriod(now) - } else { - // TODO actually calculate the correct start time accurately for cron. - quantizedRangeStart = now - } + nextRun := sched.Next(started) eventext.MergeEventFields( event, common.MapStr{ "monitor": common.MapStr{ - "id": thisID, - "name": name, - "type": typ, - "next_run": nextRun, - "next_run_in": common.MapStr{"us": nextRun.Sub(now)}, - "quantized_range": common.MapStr{ - "gte": quantizedRangeStart, + "id": thisID, + "name": name, + "type": typ, + "timespan": common.MapStr{ + "gte": started, "lt": nextRun, }, - "quantized_grace_range": common.MapStr{ - "gte": quantizedRangeStart, - "lt": sched.Next(nextRun), - }, }, }, ) diff --git a/heartbeat/monitors/wrappers/monitors_test.go b/heartbeat/monitors/wrappers/monitors_test.go index 5025e64fad55..66222968ebb6 100644 --- a/heartbeat/monitors/wrappers/monitors_test.go +++ b/heartbeat/monitors/wrappers/monitors_test.go @@ -97,7 +97,7 @@ func TestSimpleJob(t *testing.T) { "check_group": isdef.IsString, }, }), - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, summaryValidator(1, 0), )}, nil, @@ -132,7 +132,7 @@ func TestErrorJob(t *testing.T) { []validator.Validator{ lookslike.Compose( errorJobValidator, - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, summaryValidator(0, 1), )}, nil, @@ -157,7 +157,7 @@ func TestMultiJobNoConts(t *testing.T) { "check_group": uniqScope.IsUniqueTo("check_group"), }, }), - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, summaryValidator(1, 0), ) } @@ -206,7 +206,7 @@ func TestMultiJobConts(t *testing.T) { "check_group": uniqScope.IsUniqueTo(u), }, }), - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, ) } @@ -266,7 +266,7 @@ func TestMultiJobContsCancelledEvents(t *testing.T) { "check_group": uniqScope.IsUniqueTo(u), }, }), - hbtestllext.MonitorNextRunValidator, + hbtestllext.MonitorTimespanValidator, ) } diff --git a/heartbeat/scheduler/schedule/quantize/quantize.go b/heartbeat/scheduler/schedule/quantize/quantize.go deleted file mode 100644 index 7b985a319876..000000000000 --- a/heartbeat/scheduler/schedule/quantize/quantize.go +++ /dev/null @@ -1,10 +0,0 @@ -package quantize - -import "time" - -func Quantize(t time.Time, period time.Duration) (start time.Time, end time.Time) { - periodUnix := time.Unix(int64(period/time.Second), 0).Unix() - start = time.Unix((t.Unix()/periodUnix)*periodUnix, 0) - end = start.Add(period) - return start, end -} diff --git a/heartbeat/scheduler/schedule/schedule.go b/heartbeat/scheduler/schedule/schedule.go index 83ec8cfc5e65..fe7ed9fdfcb3 100644 --- a/heartbeat/scheduler/schedule/schedule.go +++ b/heartbeat/scheduler/schedule/schedule.go @@ -21,8 +21,6 @@ import ( "strings" "time" - "github.com/elastic/beats/heartbeat/scheduler/schedule/quantize" - "github.com/elastic/beats/heartbeat/scheduler" "github.com/elastic/beats/heartbeat/scheduler/schedule/cron" ) @@ -35,10 +33,6 @@ type IntervalScheduler struct { interval time.Duration } -func (s IntervalScheduler) QuantizedPeriod(now time.Time) (gte time.Time, lt time.Time) { - return quantize.Quantize(now, s.interval) -} - func Parse(in string) (*Schedule, error) { every := "@every" From 3e4e8ea110e175d2b7e842c0993c5266ad3435e1 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 25 Nov 2019 19:54:44 -0600 Subject: [PATCH 011/102] fix tests --- heartbeat/monitors/active/http/http_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 0837fd43db14..50901c888d4c 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -474,7 +474,8 @@ func TestRedirect(t *testing.T) { jobs, _, err := create("redirect", config) require.NoError(t, err) - job := wrappers.WrapCommon(jobs, "test", "", "http")[0] + sched, _ := schedule.Parse("@every 1s") + job := wrappers.WrapCommon(jobs, "test", "", "http", sched)[0] event := &beat.Event{} _, err = job(event) From c9b39cb4d7ba71e42cdf19ed56df87aa6a3ad937 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 25 Nov 2019 19:57:48 -0600 Subject: [PATCH 012/102] fix relnote --- CHANGELOG.next.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 0ad3033dc760..8432156f0c45 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -427,7 +427,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Enable `add_observer_metadata` processor in default config. {pull}11394[11394] - Record HTTP body metadata and optionally contents in `http.response.body.*` fields. {pull}13022[13022] -- Add `monitor.next_run` and `monitor.next_run_in` fields. {pull}13672[13672] +- Add `monitor.timespan` field for optimized queries in kibana. {pull}13672[13672] - Allow `hosts` to be used to configure http monitors {pull}13703[13703] *Journalbeat* From a00aa0fddaaf420a7338d6ada2c3d11a10aac9ee Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 25 Nov 2019 19:58:35 -0600 Subject: [PATCH 013/102] Fmt --- heartbeat/monitors/active/http/http_test.go | 3 ++- heartbeat/monitors/pluginconf.go | 3 ++- heartbeat/monitors/wrappers/monitors.go | 7 ++++--- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 50901c888d4c..35f9bfb4f512 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -31,6 +31,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/elastic/beats/heartbeat/hbtest" "github.com/elastic/beats/heartbeat/monitors/wrappers" schedule "github.com/elastic/beats/heartbeat/scheduler/schedule" @@ -42,7 +44,6 @@ import ( "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" - "github.com/stretchr/testify/require" ) func testRequest(t *testing.T, testURL string, useUrls bool) *beat.Event { diff --git a/heartbeat/monitors/pluginconf.go b/heartbeat/monitors/pluginconf.go index 769e7c589ae6..76ae44d1c689 100644 --- a/heartbeat/monitors/pluginconf.go +++ b/heartbeat/monitors/pluginconf.go @@ -18,9 +18,10 @@ package monitors import ( + "github.com/pkg/errors" + "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/common" - "github.com/pkg/errors" ) // ErrPluginDisabled is returned when the monitor plugin is marked as disabled. diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 83ae6b73c12f..223855578567 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -22,6 +22,10 @@ import ( "sync" "time" + "github.com/gofrs/uuid" + "github.com/mitchellh/hashstructure" + "github.com/pkg/errors" + "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/look" "github.com/elastic/beats/heartbeat/monitors/jobs" @@ -29,9 +33,6 @@ import ( "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/libbeat/logp" - "github.com/gofrs/uuid" - "github.com/mitchellh/hashstructure" - "github.com/pkg/errors" ) // WrapCommon applies the common wrappers that all monitor jobs get. From e1d0c656e54d1a2bc40a771c4128c1b6923462f8 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 25 Nov 2019 20:02:14 -0600 Subject: [PATCH 014/102] Tweaks --- heartbeat/monitors/active/tcp/tcp_test.go | 14 ++++------- heartbeat/monitors/mocks_test.go | 14 ++++------- heartbeat/monitors/pluginconf.go | 3 +-- heartbeat/monitors/wrappers/monitors_test.go | 17 +++++-------- heartbeat/scheduler/schedule/schedule.go | 7 +++--- heartbeat/scheduler/schedule/schedule_test.go | 24 +++++++++---------- 6 files changed, 33 insertions(+), 46 deletions(-) diff --git a/heartbeat/monitors/active/tcp/tcp_test.go b/heartbeat/monitors/active/tcp/tcp_test.go index 4e4ee70d5dca..b022e1e82ce5 100644 --- a/heartbeat/monitors/active/tcp/tcp_test.go +++ b/heartbeat/monitors/active/tcp/tcp_test.go @@ -28,20 +28,16 @@ import ( "strconv" "testing" - "github.com/elastic/beats/heartbeat/scheduler/schedule" - - "github.com/elastic/go-lookslike/isdef" - - "github.com/stretchr/testify/require" - - "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/testslike" - "github.com/elastic/beats/heartbeat/hbtest" "github.com/elastic/beats/heartbeat/monitors/wrappers" + "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" btesting "github.com/elastic/beats/libbeat/testing" + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/isdef" + "github.com/elastic/go-lookslike/testslike" + "github.com/stretchr/testify/require" ) func testTCPCheck(t *testing.T, host string, port uint16) *beat.Event { diff --git a/heartbeat/monitors/mocks_test.go b/heartbeat/monitors/mocks_test.go index 4af7878b38a3..d2f9986e1f42 100644 --- a/heartbeat/monitors/mocks_test.go +++ b/heartbeat/monitors/mocks_test.go @@ -23,21 +23,17 @@ import ( "sync" "testing" - "github.com/elastic/beats/heartbeat/hbtestllext" - - "github.com/elastic/go-lookslike/isdef" - "github.com/elastic/go-lookslike/validator" - - "github.com/stretchr/testify/require" - - "github.com/elastic/go-lookslike" - "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/hbtest" + "github.com/elastic/beats/heartbeat/hbtestllext" "github.com/elastic/beats/heartbeat/monitors/jobs" "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/libbeat/monitoring" + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/isdef" + "github.com/elastic/go-lookslike/validator" + "github.com/stretchr/testify/require" ) type MockBeatClient struct { diff --git a/heartbeat/monitors/pluginconf.go b/heartbeat/monitors/pluginconf.go index 76ae44d1c689..769e7c589ae6 100644 --- a/heartbeat/monitors/pluginconf.go +++ b/heartbeat/monitors/pluginconf.go @@ -18,10 +18,9 @@ package monitors import ( - "github.com/pkg/errors" - "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/common" + "github.com/pkg/errors" ) // ErrPluginDisabled is returned when the monitor plugin is marked as disabled. diff --git a/heartbeat/monitors/wrappers/monitors_test.go b/heartbeat/monitors/wrappers/monitors_test.go index 66222968ebb6..08e2539a9757 100644 --- a/heartbeat/monitors/wrappers/monitors_test.go +++ b/heartbeat/monitors/wrappers/monitors_test.go @@ -22,23 +22,18 @@ import ( "net/url" "testing" + "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/hbtestllext" + "github.com/elastic/beats/heartbeat/monitors/jobs" "github.com/elastic/beats/heartbeat/scheduler/schedule" - + "github.com/elastic/beats/libbeat/beat" + "github.com/elastic/beats/libbeat/common" + "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/isdef" - + "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - - "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/testslike" - - "github.com/elastic/beats/heartbeat/eventext" - "github.com/elastic/beats/heartbeat/monitors/jobs" - "github.com/elastic/beats/libbeat/beat" - "github.com/elastic/beats/libbeat/common" ) type fields struct { diff --git a/heartbeat/scheduler/schedule/schedule.go b/heartbeat/scheduler/schedule/schedule.go index fe7ed9fdfcb3..fd79afc7aedc 100644 --- a/heartbeat/scheduler/schedule/schedule.go +++ b/heartbeat/scheduler/schedule/schedule.go @@ -29,7 +29,8 @@ type Schedule struct { scheduler.Schedule } -type IntervalScheduler struct { +// intervalScheduler defines a schedule that runs at fixed intervals. +type intervalScheduler struct { interval time.Duration } @@ -44,7 +45,7 @@ func Parse(in string) (*Schedule, error) { return nil, err } - return &Schedule{IntervalScheduler{d}}, nil + return &Schedule{intervalScheduler{d}}, nil } // fallback on cron scheduler parsers @@ -55,7 +56,7 @@ func Parse(in string) (*Schedule, error) { return &Schedule{s}, nil } -func (s IntervalScheduler) Next(t time.Time) time.Time { +func (s intervalScheduler) Next(t time.Time) time.Time { return t.Add(s.interval) } diff --git a/heartbeat/scheduler/schedule/schedule_test.go b/heartbeat/scheduler/schedule/schedule_test.go index 50290ef3c0ee..2d0bed8d8362 100644 --- a/heartbeat/scheduler/schedule/schedule_test.go +++ b/heartbeat/scheduler/schedule/schedule_test.go @@ -36,13 +36,13 @@ func TestParse(t *testing.T) { { "every second", "@every 1s", - &Schedule{IntervalScheduler{time.Duration(1 * time.Second)}}, + &Schedule{intervalScheduler{time.Duration(1 * time.Second)}}, false, }, { "every year", "@every 1m", - &Schedule{IntervalScheduler{time.Duration(1 * time.Minute)}}, + &Schedule{intervalScheduler{time.Duration(1 * time.Minute)}}, false, }, { @@ -88,24 +88,24 @@ func Test_intervalScheduler_Next(t *testing.T) { tests := []struct { name string - s IntervalScheduler + s intervalScheduler want time.Time }{ { "one second", - IntervalScheduler{time.Duration(time.Second)}, + intervalScheduler{time.Duration(time.Second)}, now.Add(time.Second), }, { "one minute", - IntervalScheduler{time.Duration(time.Minute)}, + intervalScheduler{time.Duration(time.Minute)}, now.Add(time.Minute), }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := tt.s.Next(now); !reflect.DeepEqual(got, tt.want) { - t.Errorf("IntervalScheduler.Next() = %v, want %v", got, tt.want) + t.Errorf("intervalScheduler.Next() = %v, want %v", got, tt.want) } }) } @@ -121,30 +121,30 @@ func TestSchedule_Unpack(t *testing.T) { }{ { "one minute -> one second", - &Schedule{IntervalScheduler{time.Minute}}, + &Schedule{intervalScheduler{time.Minute}}, "@every 1s", - IntervalScheduler{time.Second}, + intervalScheduler{time.Second}, false, }, { "every 15 cron -> every second interval", &Schedule{cron.MustParse("*/15 * * * *")}, "@every 1s", - IntervalScheduler{time.Second}, + intervalScheduler{time.Second}, false, }, { "every second interval -> every 15 cron", - &Schedule{IntervalScheduler{time.Second}}, + &Schedule{intervalScheduler{time.Second}}, "*/15 * * * *", cron.MustParse("*/15 * * * *"), false, }, { "bad format", - &Schedule{IntervalScheduler{time.Minute}}, + &Schedule{intervalScheduler{time.Minute}}, "foobar", - IntervalScheduler{time.Minute}, + intervalScheduler{time.Minute}, true, }, } From da1fde17de2810aef6f6452a7ba38d0f9b7357e0 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 26 Nov 2019 15:12:28 -0600 Subject: [PATCH 015/102] Factor timeout into timespans --- heartbeat/monitors/active/http/http_test.go | 6 +-- heartbeat/monitors/active/tcp/tcp_test.go | 5 ++- heartbeat/monitors/monitor.go | 2 +- heartbeat/monitors/pluginconf.go | 3 ++ heartbeat/monitors/wrappers/monitors.go | 35 +++++++++------ heartbeat/monitors/wrappers/monitors_test.go | 45 +++++++++++++++++++- 6 files changed, 76 insertions(+), 20 deletions(-) diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 35f9bfb4f512..9066306de86e 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -76,7 +76,7 @@ func testTLSRequest(t *testing.T, testURL string, useUrls bool, extraConfig map[ require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(jobs, "tls", "", "http", sched)[0] + job := wrappers.WrapCommon(jobs, "tls", "", "http", sched, time.Duration(0))[0] event := &beat.Event{} _, err = job(event) @@ -304,7 +304,7 @@ func TestLargeResponse(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(jobs, "test", "", "http", sched)[0] + job := wrappers.WrapCommon(jobs, "test", "", "http", sched, time.Duration(0))[0] event := &beat.Event{} _, err = job(event) @@ -476,7 +476,7 @@ func TestRedirect(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(jobs, "test", "", "http", sched)[0] + job := wrappers.WrapCommon(jobs, "test", "", "http", sched, time.Duration(0))[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/active/tcp/tcp_test.go b/heartbeat/monitors/active/tcp/tcp_test.go index b022e1e82ce5..c78068b44313 100644 --- a/heartbeat/monitors/active/tcp/tcp_test.go +++ b/heartbeat/monitors/active/tcp/tcp_test.go @@ -27,6 +27,7 @@ import ( "os" "strconv" "testing" + "time" "github.com/elastic/beats/heartbeat/hbtest" "github.com/elastic/beats/heartbeat/monitors/wrappers" @@ -57,7 +58,7 @@ func testTCPConfigCheck(t *testing.T, configMap common.MapStr, host string, port require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(jobs, "test", "", "tcp", sched)[0] + job := wrappers.WrapCommon(jobs, "test", "", "tcp", sched, time.Duration(0))[0] event := &beat.Event{} _, err = job(event) @@ -81,7 +82,7 @@ func testTLSTCPCheck(t *testing.T, host string, port uint16, certFileName string require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(jobs, "test", "", "tcp", sched)[0] + job := wrappers.WrapCommon(jobs, "test", "", "tcp", sched, time.Duration(0))[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/monitor.go b/heartbeat/monitors/monitor.go index a74b98b30191..01213f2ad2d1 100644 --- a/heartbeat/monitors/monitor.go +++ b/heartbeat/monitors/monitor.go @@ -163,7 +163,7 @@ func newMonitorUnsafe( } rawJobs, endpoints, err := monitorPlugin.create(config) - wrappedJobs := wrappers.WrapCommon(rawJobs, m.id, m.name, m.typ, mpi.Schedule) + wrappedJobs := wrappers.WrapCommon(rawJobs, m.id, m.name, m.typ, mpi.Schedule, mpi.Timeout) m.endpoints = endpoints if err != nil { diff --git a/heartbeat/monitors/pluginconf.go b/heartbeat/monitors/pluginconf.go index 769e7c589ae6..d9b7071a3344 100644 --- a/heartbeat/monitors/pluginconf.go +++ b/heartbeat/monitors/pluginconf.go @@ -18,6 +18,8 @@ package monitors import ( + "time" + "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/common" "github.com/pkg/errors" @@ -32,6 +34,7 @@ type MonitorPluginInfo struct { Name string `config:"name"` Type string `config:"type" validate:"required"` Schedule *schedule.Schedule `config:"schedule" validate:"required"` + Timeout time.Duration `config:"timeout"` Enabled bool `config:"enabled"` } diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 223855578567..c565d7481c09 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -22,6 +22,8 @@ import ( "sync" "time" + "github.com/elastic/beats/heartbeat/scheduler/schedule" + "github.com/gofrs/uuid" "github.com/mitchellh/hashstructure" "github.com/pkg/errors" @@ -29,28 +31,27 @@ import ( "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/look" "github.com/elastic/beats/heartbeat/monitors/jobs" - "github.com/elastic/beats/heartbeat/scheduler" "github.com/elastic/beats/libbeat/beat" "github.com/elastic/beats/libbeat/common" "github.com/elastic/beats/libbeat/logp" ) // WrapCommon applies the common wrappers that all monitor jobs get. -func WrapCommon(js []jobs.Job, id string, name string, typ string, schedule scheduler.Schedule) []jobs.Job { +func WrapCommon(js []jobs.Job, id string, name string, typ string, sched *schedule.Schedule, timeout time.Duration) []jobs.Job { return jobs.WrapAllSeparately( jobs.WrapAll( js, addMonitorStatus, addMonitorDuration, ), func() jobs.JobWrapper { - return addMonitorMeta(id, name, typ, len(js) > 1, schedule) + return addMonitorMeta(id, name, typ, len(js) > 1, sched, timeout) }, func() jobs.JobWrapper { return makeAddSummary() }) } // addMonitorMeta adds the id, name, and type fields to the monitor. -func addMonitorMeta(id string, name string, typ string, isMulti bool, sched scheduler.Schedule) jobs.JobWrapper { +func addMonitorMeta(id string, name string, typ string, isMulti bool, sched *schedule.Schedule, timeout time.Duration) jobs.JobWrapper { return func(job jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { started := time.Now() @@ -67,19 +68,14 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool, sched sche thisID = fmt.Sprintf("%s-%x", id, urlHash) } - nextRun := sched.Next(started) - eventext.MergeEventFields( event, common.MapStr{ "monitor": common.MapStr{ - "id": thisID, - "name": name, - "type": typ, - "timespan": common.MapStr{ - "gte": started, - "lt": nextRun, - }, + "id": thisID, + "name": name, + "type": typ, + "timespan": timespan(started, sched, timeout), }, }, ) @@ -89,6 +85,19 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool, sched sche } } +func timespan(started time.Time, sched *schedule.Schedule, timeout time.Duration) common.MapStr { + maxEnd := sched.Next(started) + + if maxEnd.Sub(started) < timeout { + maxEnd = started.Add(timeout) + } + + return common.MapStr{ + "gte": started, + "lt": maxEnd, + } +} + // addMonitorStatus wraps the given Job's execution such that any error returned // by the original Job will be set as a field. The original error will not be // passed through as a return value. Errors may still be present but only if there diff --git a/heartbeat/monitors/wrappers/monitors_test.go b/heartbeat/monitors/wrappers/monitors_test.go index 08e2539a9757..6b22ac4011ad 100644 --- a/heartbeat/monitors/wrappers/monitors_test.go +++ b/heartbeat/monitors/wrappers/monitors_test.go @@ -20,7 +20,9 @@ package wrappers import ( "fmt" "net/url" + "reflect" "testing" + "time" "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/hbtestllext" @@ -53,7 +55,7 @@ type testDef struct { func testCommonWrap(t *testing.T, tt testDef) { t.Run(tt.name, func(t *testing.T) { schedule, _ := schedule.Parse("@every 1s") - wrapped := WrapCommon(tt.jobs, tt.fields.id, tt.fields.name, tt.fields.typ, schedule) + wrapped := WrapCommon(tt.jobs, tt.fields.id, tt.fields.name, tt.fields.typ, schedule, time.Duration(0)) results, err := jobs.ExecJobsAndConts(t, wrapped) assert.NoError(t, err) @@ -320,3 +322,44 @@ func summaryValidator(up int, down int) validator.Validator { }, }) } + +func TestTimespan(t *testing.T) { + now := time.Now() + sched10s, err := schedule.Parse("@every 10s") + require.NoError(t, err) + + type args struct { + started time.Time + sched *schedule.Schedule + timeout time.Duration + } + tests := []struct { + name string + args args + want common.MapStr + }{ + { + "interval longer than timeout", + args{now, sched10s, time.Second}, + common.MapStr{ + "gte": now, + "lt": now.Add(time.Second * 10), + }, + }, + { + "timeout longer than interval", + args{now, sched10s, time.Second * 20}, + common.MapStr{ + "gte": now, + "lt": now.Add(time.Second * 20), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := timespan(tt.args.started, tt.args.sched, tt.args.timeout); !reflect.DeepEqual(got, tt.want) { + t.Errorf("timespan() = %v, want %v", got, tt.want) + } + }) + } +} From 4e08b3d676ca7af9e51a11abf5a5e38fa58c1742 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 26 Nov 2019 15:13:43 -0600 Subject: [PATCH 016/102] fmt --- heartbeat/monitors/active/tcp/tcp_test.go | 3 ++- heartbeat/monitors/mocks_test.go | 3 ++- heartbeat/monitors/pluginconf.go | 3 ++- heartbeat/monitors/wrappers/monitors_test.go | 5 +++-- 4 files changed, 9 insertions(+), 5 deletions(-) diff --git a/heartbeat/monitors/active/tcp/tcp_test.go b/heartbeat/monitors/active/tcp/tcp_test.go index c78068b44313..22d42b0173fb 100644 --- a/heartbeat/monitors/active/tcp/tcp_test.go +++ b/heartbeat/monitors/active/tcp/tcp_test.go @@ -29,6 +29,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/elastic/beats/heartbeat/hbtest" "github.com/elastic/beats/heartbeat/monitors/wrappers" "github.com/elastic/beats/heartbeat/scheduler/schedule" @@ -38,7 +40,6 @@ import ( "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/testslike" - "github.com/stretchr/testify/require" ) func testTCPCheck(t *testing.T, host string, port uint16) *beat.Event { diff --git a/heartbeat/monitors/mocks_test.go b/heartbeat/monitors/mocks_test.go index d2f9986e1f42..6fa1793d4f7c 100644 --- a/heartbeat/monitors/mocks_test.go +++ b/heartbeat/monitors/mocks_test.go @@ -23,6 +23,8 @@ import ( "sync" "testing" + "github.com/stretchr/testify/require" + "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/hbtest" "github.com/elastic/beats/heartbeat/hbtestllext" @@ -33,7 +35,6 @@ import ( "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/validator" - "github.com/stretchr/testify/require" ) type MockBeatClient struct { diff --git a/heartbeat/monitors/pluginconf.go b/heartbeat/monitors/pluginconf.go index d9b7071a3344..20aace700fdb 100644 --- a/heartbeat/monitors/pluginconf.go +++ b/heartbeat/monitors/pluginconf.go @@ -20,9 +20,10 @@ package monitors import ( "time" + "github.com/pkg/errors" + "github.com/elastic/beats/heartbeat/scheduler/schedule" "github.com/elastic/beats/libbeat/common" - "github.com/pkg/errors" ) // ErrPluginDisabled is returned when the monitor plugin is marked as disabled. diff --git a/heartbeat/monitors/wrappers/monitors_test.go b/heartbeat/monitors/wrappers/monitors_test.go index 6b22ac4011ad..51e17890e495 100644 --- a/heartbeat/monitors/wrappers/monitors_test.go +++ b/heartbeat/monitors/wrappers/monitors_test.go @@ -24,6 +24,9 @@ import ( "testing" "time" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/elastic/beats/heartbeat/eventext" "github.com/elastic/beats/heartbeat/hbtestllext" "github.com/elastic/beats/heartbeat/monitors/jobs" @@ -34,8 +37,6 @@ import ( "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" ) type fields struct { From 0150408ed63708414f3800114aa2c280aecefbc6 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 12 Dec 2019 10:40:58 -0600 Subject: [PATCH 017/102] Don't require docs on date_range sub-keys --- libbeat/tests/system/beat/beat.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/libbeat/tests/system/beat/beat.py b/libbeat/tests/system/beat/beat.py index d26ac75a071e..51b9fed6c637 100644 --- a/libbeat/tests/system/beat/beat.py +++ b/libbeat/tests/system/beat/beat.py @@ -674,6 +674,7 @@ def field_pattern_match(pattern, key): return True def is_documented(key, docs): + #print("docs {}".format(docs)) if key in docs: return True for pattern in (f for f in docs if "*" in f): @@ -683,7 +684,9 @@ def is_documented(key, docs): for key in flat.keys(): metaKey = key.startswith('@metadata.') - if not(is_documented(key, expected_fields) or metaKey): + # Range keys as used in 'date_range' etc will not have docs of course + isRangeKey = key.split('.')[-1] in ['gte', 'gt', 'lte', 'lt']; + if not(is_documented(key, expected_fields) or metaKey or isRangeKey): raise Exception("Key '{}' found in event is not documented!".format(key)) if is_documented(key, aliases): raise Exception("Key '{}' found in event is documented as an alias!".format(key)) From 95acb3c14a3bd4d094307c32988f9bd65a80ad05 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 12 Dec 2019 10:42:11 -0600 Subject: [PATCH 018/102] Remove print --- libbeat/tests/system/beat/beat.py | 1 - 1 file changed, 1 deletion(-) diff --git a/libbeat/tests/system/beat/beat.py b/libbeat/tests/system/beat/beat.py index 51b9fed6c637..eb3f9a2569b3 100644 --- a/libbeat/tests/system/beat/beat.py +++ b/libbeat/tests/system/beat/beat.py @@ -674,7 +674,6 @@ def field_pattern_match(pattern, key): return True def is_documented(key, docs): - #print("docs {}".format(docs)) if key in docs: return True for pattern in (f for f in docs if "*" in f): From 7b2162a12a738e640f222b0c5f63d1a7dc12ee63 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 13 Dec 2019 16:35:04 -0600 Subject: [PATCH 019/102] FMT --- libbeat/tests/system/beat/beat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libbeat/tests/system/beat/beat.py b/libbeat/tests/system/beat/beat.py index eb3f9a2569b3..d2f7f5b83fe3 100644 --- a/libbeat/tests/system/beat/beat.py +++ b/libbeat/tests/system/beat/beat.py @@ -684,7 +684,7 @@ def is_documented(key, docs): for key in flat.keys(): metaKey = key.startswith('@metadata.') # Range keys as used in 'date_range' etc will not have docs of course - isRangeKey = key.split('.')[-1] in ['gte', 'gt', 'lte', 'lt']; + isRangeKey = key.split('.')[-1] in ['gte', 'gt', 'lte', 'lt'] if not(is_documented(key, expected_fields) or metaKey or isRangeKey): raise Exception("Key '{}' found in event is not documented!".format(key)) if is_documented(key, aliases): From 8feb08593eefd6f531ea759c908134675c5c5ee4 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 16 Dec 2019 13:47:25 -0600 Subject: [PATCH 020/102] Checkpoint --- heartbeat/monitors/wrappers/monitors.go | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitors.go b/heartbeat/monitors/wrappers/monitors.go index 53805ebef91a..ce38e53d4d8a 100644 --- a/heartbeat/monitors/wrappers/monitors.go +++ b/heartbeat/monitors/wrappers/monitors.go @@ -76,17 +76,17 @@ func addMonitorMeta(id string, name string, typ string, isMulti bool) jobs.JobWr trackerId := fmt.Sprintf("%s-%s", id, ip) stateTrackerMtx.Lock() - cssId := stateTracker.getID(trackerId, trackerStatus) + sb := statusBlockTracker.getID(trackerId, trackerStatus) stateTrackerMtx.Unlock() eventext.MergeEventFields( event, common.MapStr{ "monitor": common.MapStr{ - "id": thisID, - "name": name, - "type": typ, - "continuous_status_segment": cssId, + "id": thisID, + "name": name, + "type": typ, + "status_block": sb, }, }, ) @@ -244,12 +244,12 @@ func (mst *monitorStateTracker) getID(monitorId string, currentStatus stateStatu return mst.get(monitorId, currentStatus).startedAt } -// TODO this is obviously a memory leak and for the POC only -var stateTracker = &monitorStateTracker{ - states: map[string]*monitorState{}, - mtx: sync.Mutex{}, +func newStatusBlockTracker() *monitorStateTracker { + return &monitorStateTracker{ + states: map[string]*monitorState{}, + mtx: sync.Mutex{}, + } } -var stateTrackerMtx = sync.Mutex{} // makeAddSummary summarizes the job, adding the `summary` field to the last event emitted. func makeAddSummary() jobs.JobWrapper { @@ -318,7 +318,7 @@ func makeAddSummary() jobs.JobWrapper { } monitorIdString, _ := monitorId.(string) stateTrackerMtx.Lock() - cssId := stateTracker.getID(monitorIdString, trackerStatus) + cssId := statusBlockTracker.getID(monitorIdString, trackerStatus) stateTrackerMtx.Unlock() eventext.MergeEventFields(event, common.MapStr{ "summary": common.MapStr{ From 67a41914736d616dfb2f7db18c5d910f07b1d8e9 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 9 Mar 2022 20:21:58 -0600 Subject: [PATCH 021/102] More --- go.mod | 2 + go.sum | 4 ++ heartbeat/beater/heartbeat.go | 14 +++++++ heartbeat/include/fields.go | 2 +- heartbeat/monitors/monitor.go | 11 +++--- .../wrappers/monitorstate/monitorstate.go | 6 +-- heartbeat/monitors/wrappers/wrappers.go | 39 +++++++++---------- 7 files changed, 48 insertions(+), 30 deletions(-) diff --git a/go.mod b/go.mod index 414ce1e38ded..d70427752a62 100644 --- a/go.mod +++ b/go.mod @@ -218,6 +218,8 @@ require ( github.com/docker/distribution v2.8.0+incompatible // indirect github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21 // indirect github.com/eapache/queue v1.1.0 // indirect + github.com/elastic/elastic-transport-go/v8 v8.0.0-alpha // indirect + github.com/elastic/go-elasticsearch/v8 v8.0.0 // indirect github.com/evanphx/json-patch v4.12.0+incompatible // indirect github.com/fearful-symmetry/gomsr v0.0.1 // indirect github.com/go-logr/logr v1.2.0 // indirect diff --git a/go.sum b/go.sum index 73d67b979fc3..4ba9be8b0ff4 100644 --- a/go.sum +++ b/go.sum @@ -514,12 +514,16 @@ github.com/elastic/dhcp v0.0.0-20200227161230-57ec251c7eb3 h1:lnDkqiRFKm0rxdljqr github.com/elastic/dhcp v0.0.0-20200227161230-57ec251c7eb3/go.mod h1:aPqzac6AYkipvp4hufTyMj5PDIphF3+At8zr7r51xjY= github.com/elastic/elastic-agent-client/v7 v7.0.0-20210727140539-f0905d9377f6 h1:nFvXHBjYK3e9+xF0WKDeAKK4aOO51uC28s+L9rBmilo= github.com/elastic/elastic-agent-client/v7 v7.0.0-20210727140539-f0905d9377f6/go.mod h1:uh/Gj9a0XEbYoM4NYz4LvaBVARz3QXLmlNjsrKY9fTc= +github.com/elastic/elastic-transport-go/v8 v8.0.0-alpha h1:SW9xcMVxx4Nv9oRm5rQxzAMAatwiZV8xROP2a48y45Q= +github.com/elastic/elastic-transport-go/v8 v8.0.0-alpha/go.mod h1:87Tcz8IVNe6rVSLdBux1o/PEItLtyabHU3naC7IoqKI= github.com/elastic/fsevents v0.0.0-20181029231046-e1d381a4d270 h1:cWPqxlPtir4RoQVCpGSRXmLqjEHpJKbR60rxh1nQZY4= github.com/elastic/fsevents v0.0.0-20181029231046-e1d381a4d270/go.mod h1:Msl1pdboCbArMF/nSCDUXgQuWTeoMmE/z8607X+k7ng= github.com/elastic/glog v1.0.1-0.20210831205241-7d8b5c89dfc4 h1:ViJxdtOsHeO+SWVekzM82fYHH1xnvZ8CvGPXZj+G4YI= github.com/elastic/glog v1.0.1-0.20210831205241-7d8b5c89dfc4/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/elastic/go-concert v0.2.0 h1:GAQrhRVXprnNjtvTP9pWJ1d4ToEA4cU5ci7TwTa20xg= github.com/elastic/go-concert v0.2.0/go.mod h1:HWjpO3IAEJUxOeaJOWXWEp7imKd27foxz9V5vegC/38= +github.com/elastic/go-elasticsearch/v8 v8.0.0 h1:Hte+pgoEZI88j/sQx7u9vK9SqisvJYkYMmxDnQXiJyM= +github.com/elastic/go-elasticsearch/v8 v8.0.0/go.mod h1:8NCWP26meGbncX+R9sxo2JD8IqBjRTuS7yXMstHpd40= github.com/elastic/go-libaudit/v2 v2.2.0 h1:TY3FDpG4Zr9Qnv6KYW6olYr/U+nfu0rD2QAbv75VxMQ= github.com/elastic/go-libaudit/v2 v2.2.0/go.mod h1:MM/l/4xV7ilcl+cIblL8Zn448J7RZaDwgNLE4gNKYPg= github.com/elastic/go-licenser v0.4.0 h1:jLq6A5SilDS/Iz1ABRkO6BHy91B9jBora8FwGRsDqUI= diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 003f4da59343..5e425b770d39 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -50,8 +50,22 @@ type Heartbeat struct { autodiscover *autodiscover.Autodiscover } +type CloudConfig struct { + Cloud struct { + ID string `config:"id"` + Auth string `config:"auth"` + } `config:"cloud"` +} + // New creates a new heartbeat. func New(b *beat.Beat, rawConfig *common.Config) (beat.Beater, error) { + //es8, _ := elasticsearch8.NewDefaultClient() + + //cloudConfig{} + //elasticsearch8.NewClient(elasticsearch8.Config{ + // CloudID: cfg.CloudID, + //}) + parsedConfig := config.DefaultConfig if err := rawConfig.Unpack(&parsedConfig); err != nil { return nil, fmt.Errorf("Error reading config file: %v", err) diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 4a9ca44addc4..b83919a1d8d8 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/heartbeat/monitors/monitor.go b/heartbeat/monitors/monitor.go index 91a6a881d848..4abf1033637b 100644 --- a/heartbeat/monitors/monitor.go +++ b/heartbeat/monitors/monitor.go @@ -236,8 +236,8 @@ func (m *Monitor) Start() { defer m.internalsMtx.Unlock() for _, t := range m.configuredJobs { + client, err := pipeline.NewSyncClient(logp.NewLogger("monitor_task"), t.monitor.pipelineConnector, beat.ClientConfig{}) if m.runOnce { - client, err := pipeline.NewSyncClient(logp.NewLogger("monitor_task"), t.monitor.pipelineConnector, beat.ClientConfig{}) if err != nil { logp.Err("could not start monitor: %v", err) continue @@ -250,15 +250,16 @@ func (m *Monitor) Start() { wait: client.Wait, }) } else { - client, err := m.pipelineConnector.Connect() if err != nil { logp.Err("could not start monitor: %v", err) continue } t.Start(&WrappedClient{ - Publish: client.Publish, - Close: client.Close, - wait: func() {}, + Publish: func(event beat.Event) { + client.Publish(event) + }, + Close: client.Close, + wait: func() {}, }) } } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 2d9bdadbcaed..4af00c1b0b9c 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -5,7 +5,7 @@ import ( "time" ) -const FlappingThreshold time.Duration = time.Minute +const FlappingThreshold time.Duration = time.Second * 10 const ( StatusUp stateStatus = iota @@ -52,13 +52,13 @@ func (mst *MonitorStateTracker) Compute(monitorId string, isUp bool) (curState * } } else if state.status == currentStatus { // The state is stable, no changes needed - state.Checks++ + state.recordCheck(isUp) return state, nil, nil } else if state.StartedAt.After(time.Now().Add(-FlappingThreshold)) { // The state changed too quickly, we're now flapping // TODO: is the above conditional right? state.flapCompute(currentStatus) // record the new state to the flap history - state.Checks++ + state.recordCheck(isUp) return state, nil, nil } } diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index c17845e2ab95..4a5c7effbb70 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -82,8 +82,8 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta return func(event *beat.Event) ([]jobs.Job, error) { cont, err := job(event) - // Only process state on summary events - if ok, _ := event.Fields.HasKey("summary.up"); ok { + // Only process terminal docs + if len(cont) > 0 { return cont, err } @@ -97,31 +97,36 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta stateFields := common.MapStr{ "id": ms.Id(), - "status": ms.Status, + "status": ms.Status(), } if newMs != nil { stateFields["starting"] = common.MapStr{ "id": newMs.Id(), "started_at": newMs.StartedAt.UnixMilli(), - "status": newMs.Status, + "status": newMs.Status(), } } - if newMs != nil { + if oldMs != nil { + logp.Warn("!!!ADD END") + endedAt := newMs.StartedAt.Add(-time.Millisecond) + stateFields["ending"] = common.MapStr{ - "id": oldMs.StartedAt, + "id": oldMs.Id(), "started_at": oldMs.StartedAt.UnixMilli(), // Set the end time to 1ms before the new state - "ended_at": newMs.StartedAt.Add(-time.Millisecond), - "checks": oldMs.Checks, - "up": oldMs.Up, - "down": oldMs.Down, - "status": oldMs.Status, + "ended_at": endedAt.UnixMilli(), + "duration_ms": endedAt.Sub(oldMs.StartedAt).Milliseconds(), + "checks": oldMs.Checks, + "up": oldMs.Up, + "down": oldMs.Down, + "status": oldMs.Status(), } } + logp.Warn("CHECKS: %s - u:%d d:%d", ms.Status(), ms.Up, ms.Down) - eventext.MergeEventFields(event, stateFields) + eventext.MergeEventFields(event, common.MapStr{"state": stateFields}) return cont, err } @@ -256,14 +261,6 @@ func addMonitorDuration(job jobs.Job) jobs.Job { } } -type CState struct { - id string - startedAt time.Time - endedAt time.Ticker - up int - down int -} - // makeAddSummary summarizes the job, adding the `summary` field to the last event emitted. func makeAddSummary(monitorType string) jobs.JobWrapper { // This is a tricky method. The way this works is that we track the state across jobs in the @@ -276,7 +273,6 @@ func makeAddSummary(monitorType string) jobs.JobWrapper { down uint16 checkGroup string generation uint64 - cstate CState }{ mtx: sync.Mutex{}, } @@ -334,6 +330,7 @@ func makeAddSummary(monitorType string) jobs.JobWrapper { resetState() } + logp.Warn("RET CONT %s %d / %s", state.checkGroup, len(cont), jobErr) return cont, jobErr } } From 5a15d3c424bffe105f55b4bde838c7489c1f8f7e Mon Sep 17 00:00:00 2001 From: debadair Date: Thu, 23 Jun 2022 16:32:00 -0700 Subject: [PATCH 022/102] [DOCS] Removed reference to the Stack GS (#32083) --- libbeat/docs/tab-widgets/spinup-stack.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libbeat/docs/tab-widgets/spinup-stack.asciidoc b/libbeat/docs/tab-widgets/spinup-stack.asciidoc index 1ffc7663ac31..5d12335d53e9 100644 --- a/libbeat/docs/tab-widgets/spinup-stack.asciidoc +++ b/libbeat/docs/tab-widgets/spinup-stack.asciidoc @@ -5,5 +5,5 @@ available on AWS, GCP, and Azure. {ess-trial}[Try it out for free]. // end::cloud[] // tag::self-managed[] -See {stack-gs}/get-started-elastic-stack.html[Getting started with the {stack}]. +To install and run {es} and {kib}, see {stack-ref}/installing-elastic-stack.html[Installing the {stack}]. // end::self-managed[] From a55ae5857c0d80e0834c9f3e98fd1b833675f12c Mon Sep 17 00:00:00 2001 From: debadair Date: Mon, 27 Jun 2022 10:47:47 -0700 Subject: [PATCH 023/102] [DOCS] Removed reference to the Stack GS (#32119) From de4f4def6d35f0ff95107e245eaea3631be96f1b Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 5 Jul 2022 21:10:05 -0500 Subject: [PATCH 024/102] Unblock blocked monitors test --- heartbeat/monitors/monitor.go | 10 ++++------ heartbeat/monitors/monitor_test.go | 2 ++ heartbeat/monitors/wrappers/wrappers.go | 10 ++++++---- 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/heartbeat/monitors/monitor.go b/heartbeat/monitors/monitor.go index b43ae9bff96a..61558d270e69 100644 --- a/heartbeat/monitors/monitor.go +++ b/heartbeat/monitors/monitor.go @@ -227,7 +227,6 @@ func (m *Monitor) Start() { defer m.internalsMtx.Unlock() for _, t := range m.configuredJobs { - client, err := pipeline.NewSyncClient(logp.NewLogger("monitor_task"), t.monitor.pipelineConnector, beat.ClientConfig{}) if m.runOnce { client, err := pipeline.NewSyncClient(logp.L(), t.monitor.pipelineConnector, beat.ClientConfig{}) if err != nil { @@ -242,16 +241,15 @@ func (m *Monitor) Start() { wait: client.Wait, }) } else { + client, err := m.pipelineConnector.Connect() if err != nil { logp.L().Errorf("could not start monitor: %v", err) continue } t.Start(&WrappedClient{ - Publish: func(event beat.Event) { - client.Publish(event) - }, - Close: client.Close, - wait: func() {}, + Publish: client.Publish, + Close: client.Close, + wait: func() {}, }) } } diff --git a/heartbeat/monitors/monitor_test.go b/heartbeat/monitors/monitor_test.go index 8258f9473f93..614fd9c4ab3c 100644 --- a/heartbeat/monitors/monitor_test.go +++ b/heartbeat/monitors/monitor_test.go @@ -18,6 +18,7 @@ package monitors import ( + "fmt" "testing" "time" @@ -92,6 +93,7 @@ func testMonitorConfig(t *testing.T, conf *conf.C, eventValidator validator.Vali } else { // Let's yield this goroutine so we don't spin // This could (possibly?) lock on a single core system otherwise + fmt.Println("WAITA") time.Sleep(time.Microsecond) } } diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index c8c2fdc473f8..62314479aaa0 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -97,15 +97,17 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta } status, err := event.GetValue("monitor.status") + fmt.Printf("COMPUTE START\n") ms, newMs, oldMs := mst.Compute(trackerId, status == "up") + fmt.Printf("COMPUTE END\n") - stateFields := common.MapStr{ + stateFields := mapstr.M{ "id": ms.Id(), "status": ms.Status(), } if newMs != nil { - stateFields["starting"] = common.MapStr{ + stateFields["starting"] = mapstr.M{ "id": newMs.Id(), "started_at": newMs.StartedAt.UnixMilli(), "status": newMs.Status(), @@ -116,7 +118,7 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta logp.Warn("!!!ADD END") endedAt := newMs.StartedAt.Add(-time.Millisecond) - stateFields["ending"] = common.MapStr{ + stateFields["ending"] = mapstr.M{ "id": oldMs.Id(), "started_at": oldMs.StartedAt.UnixMilli(), // Set the end time to 1ms before the new state @@ -130,7 +132,7 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta } logp.Warn("CHECKS: %s - u:%d d:%d", ms.Status(), ms.Up, ms.Down) - eventext.MergeEventFields(event, common.MapStr{"state": stateFields}) + eventext.MergeEventFields(event, mapstr.M{"state": stateFields}) return cont, err } From 18148654b67f5fc83c95ccd6b9ffe1d20adb7711 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 6 Jul 2022 11:43:42 -0500 Subject: [PATCH 025/102] Works for browsers --- heartbeat/monitors/monitor_test.go | 2 -- .../wrappers/monitorstate/monitorstate.go | 2 +- heartbeat/monitors/wrappers/wrappers.go | 29 ++++++++++++------- 3 files changed, 20 insertions(+), 13 deletions(-) diff --git a/heartbeat/monitors/monitor_test.go b/heartbeat/monitors/monitor_test.go index 614fd9c4ab3c..8258f9473f93 100644 --- a/heartbeat/monitors/monitor_test.go +++ b/heartbeat/monitors/monitor_test.go @@ -18,7 +18,6 @@ package monitors import ( - "fmt" "testing" "time" @@ -93,7 +92,6 @@ func testMonitorConfig(t *testing.T, conf *conf.C, eventValidator validator.Vali } else { // Let's yield this goroutine so we don't spin // This could (possibly?) lock on a single core system otherwise - fmt.Println("WAITA") time.Sleep(time.Microsecond) } } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 4af00c1b0b9c..2cf065e26656 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -100,7 +100,7 @@ type monitorState struct { flapHistory []historicalStatus } -func (state monitorState) Id() int64 { +func (state *monitorState) Id() int64 { return state.StartedAt.UnixMilli() } diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 62314479aaa0..0754601a8848 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -18,6 +18,7 @@ package wrappers import ( + "encoding/json" "errors" "fmt" "sync" @@ -43,7 +44,7 @@ import ( func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields) []jobs.Job { mst := monitorstate.NewMonitorStateTracker() if stdMonFields.Type == "browser" { - return WrapBrowser(js, stdMonFields) + return WrapBrowser(js, stdMonFields, mst) } else { return WrapLightweight(js, stdMonFields, mst) } @@ -69,37 +70,40 @@ func WrapLightweight(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst // WrapBrowser is pretty minimal in terms of fields added. The browser monitor // type handles most of the fields directly, since it runs multiple jobs in a single // run it needs to take this task on in a unique way. -func WrapBrowser(js []jobs.Job, stdMonFields stdfields.StdMonitorFields) []jobs.Job { +func WrapBrowser(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst *monitorstate.MonitorStateTracker) []jobs.Job { return jobs.WrapAll( js, addMonitorTimespan(stdMonFields), addServiceName(stdMonFields), addMonitorMeta(stdMonFields, false), addMonitorStatus(true), + addMonitorState(stdMonFields, mst), logJourneySummaries, ) } -// addMonitorMeta adds the id, name, and type fields to the monitor. +// addMonitorState computes the various state fields func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorStateTracker) jobs.JobWrapper { return func(job jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { cont, err := job(event) - // Only process terminal docs - if len(cont) > 0 { + hasSummary, _ := event.Fields.HasKey("summary.up") + if !hasSummary { return cont, err } + logp.Warn("TERMINAL DOC FOR %s", sf.ID) trackerId := sf.ID if ip, err := event.GetValue("monitor.ip"); err != nil { trackerId = fmt.Sprintf("%s-%s", sf.ID, ip) } status, err := event.GetValue("monitor.status") + if err != nil { + return nil, fmt.Errorf("could not wrap state for '%s', no status assigned: %w", sf.ID, err) + } - fmt.Printf("COMPUTE START\n") ms, newMs, oldMs := mst.Compute(trackerId, status == "up") - fmt.Printf("COMPUTE END\n") stateFields := mapstr.M{ "id": ms.Id(), @@ -118,23 +122,28 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta logp.Warn("!!!ADD END") endedAt := newMs.StartedAt.Add(-time.Millisecond) + durationMs := endedAt.Sub(oldMs.StartedAt).Milliseconds() + stateFields["duration_ms"] = durationMs + stateFields["ending"] = mapstr.M{ "id": oldMs.Id(), "started_at": oldMs.StartedAt.UnixMilli(), // Set the end time to 1ms before the new state "ended_at": endedAt.UnixMilli(), - "duration_ms": endedAt.Sub(oldMs.StartedAt).Milliseconds(), + "duration_ms": durationMs, "checks": oldMs.Checks, "up": oldMs.Up, "down": oldMs.Down, "status": oldMs.Status(), } } - logp.Warn("CHECKS: %s - u:%d d:%d", ms.Status(), ms.Up, ms.Down) + logp.Warn("CHECKS: %s - s:%s u:%d d:%d", sf.ID, ms.Status(), ms.Up, ms.Down) eventext.MergeEventFields(event, mapstr.M{"state": stateFields}) + f, _ := json.Marshal(event.Fields) + logp.Info("SUMMARY %s", f) - return cont, err + return cont, nil } } } From e0c8bc55fca787c3b58c05d9f45ef666ecbad68d Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 6 Jul 2022 20:59:47 -0500 Subject: [PATCH 026/102] Almost working --- heartbeat/beater/heartbeat.go | 30 +++- heartbeat/esutil/esutil.go | 51 ++++++ .../wrappers/monitorstate/monitorstate.go | 147 +++++------------- .../monitors/wrappers/monitorstate/tracker.go | 146 +++++++++++++++++ heartbeat/monitors/wrappers/wrappers.go | 42 +---- 5 files changed, 265 insertions(+), 151 deletions(-) create mode 100644 heartbeat/esutil/esutil.go create mode 100644 heartbeat/monitors/wrappers/monitorstate/tracker.go diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 28b10a1e4642..021b2b8ff60f 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -27,6 +27,7 @@ import ( "github.com/elastic/beats/v7/heartbeat/hbregistry" "github.com/elastic/beats/v7/heartbeat/monitors" "github.com/elastic/beats/v7/heartbeat/monitors/plugin" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/elastic/beats/v7/heartbeat/scheduler" "github.com/elastic/beats/v7/libbeat/autodiscover" "github.com/elastic/beats/v7/libbeat/beat" @@ -35,6 +36,7 @@ import ( "github.com/elastic/beats/v7/libbeat/management" conf "github.com/elastic/elastic-agent-libs/config" "github.com/elastic/elastic-agent-libs/logp" + "github.com/elastic/go-elasticsearch/v8" _ "github.com/elastic/beats/v7/heartbeat/security" ) @@ -50,15 +52,33 @@ type Heartbeat struct { autodiscover *autodiscover.Autodiscover } -type CloudConfig struct { - Cloud struct { - ID string `config:"id"` - Auth string `config:"auth"` - } `config:"cloud"` +type EsConfig struct { + Hosts []string `config:"hosts"` + Username string `config:"username"` + Password string `config:"password"` } // New creates a new heartbeat. func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { + + esConfig := EsConfig{} + err := b.Config.Output.Config().Unpack(&esConfig) + + if err != nil { + logp.L().Info("could not unpack cloud config for heartbeat: %w", err) + } else { + esc, err := elasticsearch.NewClient(elasticsearch.Config{ + Addresses: esConfig.Hosts, + Username: esConfig.Username, + Password: esConfig.Password, + }) + if err != nil { + return nil, fmt.Errorf("could not initialize elasticsearch client: %w", err) + } + monitorstate.SetEsClient(esc) + logp.Info("successfully connected to ES for state tracking: %v", esConfig.Hosts) + } + parsedConfig := config.DefaultConfig if err := rawConfig.Unpack(&parsedConfig); err != nil { return nil, fmt.Errorf("error reading config file: %w", err) diff --git a/heartbeat/esutil/esutil.go b/heartbeat/esutil/esutil.go new file mode 100644 index 000000000000..fdab99f618c3 --- /dev/null +++ b/heartbeat/esutil/esutil.go @@ -0,0 +1,51 @@ +package esutil + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + + "github.com/elastic/go-elasticsearch/v8/esapi" +) + +func ToJsonRdr(i interface{}) (io.Reader, error) { + b, err := json.Marshal(i) + if err != nil { + return nil, err + } + + return bytes.NewReader(b), nil +} + +func CheckResp(r *esapi.Response, argErr error) error { + if argErr != nil { + return argErr + } + if r.StatusCode >= 300 { + buf := new(bytes.Buffer) + _, err := buf.ReadFrom(r.Body) + if err != nil { + buf.WriteString(fmt.Sprintf("", err)) + } + return fmt.Errorf("bad status code for response(%d): %s", r.StatusCode, buf.String()) + } + return nil +} + +func CheckRetResp(r *esapi.Response, argErr error) (body []byte, err error) { + if argErr != nil { + return nil, argErr + } + buf := new(bytes.Buffer) + _, err = buf.ReadFrom(r.Body) + if err != nil { + return nil, fmt.Errorf("", err) + } + + if r.StatusCode >= 300 { + return nil, fmt.Errorf("bad status code for response(%d): %s", r.StatusCode, buf.String()) + } + + return buf.Bytes(), err +} diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 2cf065e26656..086e841c24ef 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -1,114 +1,56 @@ package monitorstate import ( - "sync" + "fmt" "time" ) const FlappingThreshold time.Duration = time.Second * 10 const ( - StatusUp stateStatus = iota - StatusDown - StatusFlapping + StatusUp = "up" + StatusDown = "down" + StatusFlapping = "flap" ) -func NewMonitorStateTracker() *MonitorStateTracker { - return &MonitorStateTracker{ - states: map[string]*monitorState{}, - mtx: sync.Mutex{}, - } -} - -type MonitorStateTracker struct { - states map[string]*monitorState - mtx sync.Mutex -} - -func (mst *MonitorStateTracker) Compute(monitorId string, isUp bool) (curState *monitorState, stateEnded *monitorState, startedState *monitorState) { - currentStatus := StatusDown - if isUp { - currentStatus = StatusUp - } - - //note: the return values have no concurrency controls, they may be unsafely read unless - //copied to the stack, copying the structs before returning - mst.mtx.Lock() - defer mst.mtx.Unlock() - - if state, ok := mst.states[monitorId]; ok { - if state.IsFlapping() { - // Check to see if there's still an ongoing flap after recording - // the new status - if state.flapCompute(currentStatus) { - state.recordCheck(isUp) - return state, nil, nil - } else { - oldState := *state - newState := *NewMonitorState(isUp) - internalNewState := newState // Copy the struct since the returned value is read after the mutex - mst.states[monitorId] = &internalNewState - return &newState, &newState, &oldState - } - } else if state.status == currentStatus { - // The state is stable, no changes needed - state.recordCheck(isUp) - return state, nil, nil - } else if state.StartedAt.After(time.Now().Add(-FlappingThreshold)) { - // The state changed too quickly, we're now flapping - // TODO: is the above conditional right? - state.flapCompute(currentStatus) // record the new state to the flap history - state.recordCheck(isUp) - return state, nil, nil - } - } - - // No previous state, so make a new one - newState := *NewMonitorState(isUp) - internalNewState := newState - // Use a copy of the struct so that return values can safely be used concurrently - mst.states[monitorId] = &internalNewState - return &newState, &newState, nil -} - -type stateStatus int8 - -func NewMonitorState(isUp bool) *monitorState { - ms := &monitorState{ - StartedAt: time.Now(), - Checks: 1, +func NewMonitorState(monitorId string, isUp bool) *MonitorState { + startedAtMs := time.Now().UnixMilli() + ms := &MonitorState{ + Id: fmt.Sprintf("%s-%x", monitorId, startedAtMs), + MonitorId: monitorId, + StartedAtMs: startedAtMs, + Checks: 1, } if isUp { - ms.status = StatusUp + ms.Status = StatusUp } else { - ms.status = StatusDown + ms.Status = StatusDown } return ms } -type historicalStatus struct { - ts time.Time - status stateStatus +type HistoricalStatus struct { + TsMs int64 `json:"ts_ms"` + Status string `json:"status"` } -type monitorState struct { - StartedAt time.Time - status stateStatus - Checks int - Up int - Down int - flapHistory []historicalStatus +type MonitorState struct { + MonitorId string `json:"monitorId"` + Id string `json:"id"` + StartedAtMs int64 `json:"started_at_ms"` + Status string `json:"status"` + Checks int `json:"checks"` + Up int `json:"up"` + Down int `json:"down"` + FlapHistory []HistoricalStatus `json:"flap_history"` + Ends *MonitorState `json:"ends"` } -func (state *monitorState) Id() int64 { - return state.StartedAt.UnixMilli() +func (state *MonitorState) IsFlapping() bool { + return len(state.FlapHistory) > 0 } -func (state *monitorState) IsFlapping() bool { - return len(state.flapHistory) > 0 -} - -func (state *monitorState) recordCheck(up bool) { +func (state *MonitorState) recordCheck(up bool) { state.Checks++ if up { state.Up++ @@ -117,20 +59,20 @@ func (state *monitorState) recordCheck(up bool) { } } -func (state *monitorState) isStateStillStable(currentStatus stateStatus) bool { - return state.status == currentStatus && state.IsFlapping() +func (state *MonitorState) isStateStillStable(currentStatus string) bool { + return state.Status == currentStatus && state.IsFlapping() } // flapCompute returns true if we are still flapping, false if we no longer are. -func (state *monitorState) flapCompute(currentStatus stateStatus) bool { - state.flapHistory = append(state.flapHistory, historicalStatus{time.Now(), state.status}) - state.status = currentStatus +func (state *MonitorState) flapCompute(currentStatus string) bool { + state.FlapHistory = append(state.FlapHistory, HistoricalStatus{time.Now().UnixMilli(), state.Status}) + state.Status = currentStatus // Figure out which values are old enough that we can discard them for our calculation - cutOff := time.Now().Add(-FlappingThreshold) + cutOff := time.Now().Add(-FlappingThreshold).UnixMilli() discardIndex := -1 - for idx, hs := range state.flapHistory { - if hs.ts.Before(cutOff) { + for idx, hs := range state.FlapHistory { + if hs.TsMs < cutOff { discardIndex = idx } else { break @@ -138,23 +80,14 @@ func (state *monitorState) flapCompute(currentStatus stateStatus) bool { } // Do the discarding if discardIndex != -1 { - state.flapHistory = state.flapHistory[discardIndex+1:] + state.FlapHistory = state.FlapHistory[discardIndex+1:] } // Check to see if we are no longer flapping, and if so clear flap history - for _, hs := range state.flapHistory { - if hs.status != currentStatus { + for _, hs := range state.FlapHistory { + if hs.Status != currentStatus { return false } } return true } - -func (ms *monitorState) Status() string { - if ms.Up > 0 && ms.Down > 0 { - return "flapping" - } else if ms.Up > 0 { - return "up" - } - return "down" -} diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go new file mode 100644 index 000000000000..2cb991f798f2 --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -0,0 +1,146 @@ +package monitorstate + +import ( + "bytes" + "encoding/json" + "fmt" + "sync" + "time" + + "github.com/elastic/beats/v7/heartbeat/esutil" + "github.com/elastic/elastic-agent-libs/logp" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/go-elasticsearch/v8" + "github.com/elastic/go-elasticsearch/v8/esapi" +) + +var esClient *elasticsearch.Client + +func SetEsClient(c *elasticsearch.Client) { + esClient = c +} + +func NewMonitorStateTracker() *MonitorStateTracker { + return &MonitorStateTracker{ + states: map[string]*MonitorState{}, + mtx: sync.Mutex{}, + } +} + +type MonitorStateTracker struct { + states map[string]*MonitorState + mtx sync.Mutex +} + +func (mst *MonitorStateTracker) Compute(monitorId string, isUp bool) (curState *MonitorState) { + // If state is missing load it from ES + if _, ok := mst.states[monitorId]; !ok && esClient != nil { + loadedState, err := LoadLastState(monitorId, esClient) + if err != nil { + // TODO: What behavior do we really want here? + logp.Warn("could not load last state from elasticsearch, will create new state: %w", err) + } + + mst.states[monitorId] = loadedState + } + + currentStatus := StatusDown + if isUp { + currentStatus = StatusUp + } + + //note: the return values have no concurrency controls, they may be unsafely read unless + //copied to the stack, copying the structs before returning + mst.mtx.Lock() + defer mst.mtx.Unlock() + + if state, ok := mst.states[monitorId]; ok { + if state.IsFlapping() { + // Check to see if there's still an ongoing flap after recording + // the new status + if state.flapCompute(currentStatus) { + state.recordCheck(isUp) + return state + } else { + state.Ends = state + newState := *NewMonitorState(monitorId, isUp) + internalNewState := newState // Copy the struct since the returned value is read after the mutex + mst.states[monitorId] = &internalNewState + return &newState + } + } else if state.Status == currentStatus { + // The state is stable, no changes needed + state.recordCheck(isUp) + return state + } else if state.StartedAtMs > time.Now().Add(-FlappingThreshold).UnixMilli() { + // The state changed too quickly, we're now flapping + // TODO: is the above conditional right? + state.flapCompute(currentStatus) // record the new state to the flap history + state.recordCheck(isUp) + return state + } + } + + // No previous state, so make a new one + newState := *NewMonitorState(monitorId, isUp) + internalNewState := newState + // Use a copy of the struct so that return values can safely be used concurrently + mst.states[monitorId] = &internalNewState + return &newState +} +func LoadLastState(monitorId string, esc *elasticsearch.Client) (*MonitorState, error) { + reqBody, err := json.Marshal(mapstr.M{ + "sort": mapstr.M{"@timestamp": "desc"}, + "query": mapstr.M{ + "bool": mapstr.M{ + "must": []mapstr.M{ + { + "match": mapstr.M{"monitor.id": monitorId}, + }, + { + "exists": mapstr.M{"field": "summary"}, + }, + }, + }, + }, + }) + if err != nil { + return nil, fmt.Errorf("could not serialize query for state save: %w", err) + } + + r, err := esc.Search(func(sr *esapi.SearchRequest) { + sr.Index = []string{"synthetics-*"} + size := 1 + sr.Size = &size + sr.Body = bytes.NewReader(reqBody) + }) + + type stateHits struct { + Hits struct { + Hits []struct { + DocId string `json:"string"` + Source struct { + State MonitorState `json:"state"` + } `json:"_source"` + } `json:"hits"` + } `json:"hits"` + } + + respBody, err := esutil.CheckRetResp(r, err) + if err != nil { + return nil, fmt.Errorf("error executing state search for %s: %w", monitorId, err) + } + + sh := stateHits{} + err = json.Unmarshal(respBody, &sh) + if err != nil { + return nil, fmt.Errorf("could not unmarshal state hits for %s: %w", monitorId, err) + } + + if len(sh.Hits.Hits) == 0 { + logp.Info("no previous state found for monitor %s, will initialize new state", monitorId) + return NewMonitorState(monitorId, true), nil + } + + return &sh.Hits.Hits[0].Source.State, nil +} diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 0754601a8848..b0fed9bf147d 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -94,52 +94,16 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta } logp.Warn("TERMINAL DOC FOR %s", sf.ID) - trackerId := sf.ID - if ip, err := event.GetValue("monitor.ip"); err != nil { - trackerId = fmt.Sprintf("%s-%s", sf.ID, ip) - } status, err := event.GetValue("monitor.status") if err != nil { return nil, fmt.Errorf("could not wrap state for '%s', no status assigned: %w", sf.ID, err) } - ms, newMs, oldMs := mst.Compute(trackerId, status == "up") - - stateFields := mapstr.M{ - "id": ms.Id(), - "status": ms.Status(), - } - - if newMs != nil { - stateFields["starting"] = mapstr.M{ - "id": newMs.Id(), - "started_at": newMs.StartedAt.UnixMilli(), - "status": newMs.Status(), - } - } + ms := mst.Compute(sf.ID, status == "up") - if oldMs != nil { - logp.Warn("!!!ADD END") - endedAt := newMs.StartedAt.Add(-time.Millisecond) - - durationMs := endedAt.Sub(oldMs.StartedAt).Milliseconds() - stateFields["duration_ms"] = durationMs - - stateFields["ending"] = mapstr.M{ - "id": oldMs.Id(), - "started_at": oldMs.StartedAt.UnixMilli(), - // Set the end time to 1ms before the new state - "ended_at": endedAt.UnixMilli(), - "duration_ms": durationMs, - "checks": oldMs.Checks, - "up": oldMs.Up, - "down": oldMs.Down, - "status": oldMs.Status(), - } - } - logp.Warn("CHECKS: %s - s:%s u:%d d:%d", sf.ID, ms.Status(), ms.Up, ms.Down) + logp.Warn("CHECKS: %s - s:%s u:%d d:%d", sf.ID, ms.Status, ms.Up, ms.Down) - eventext.MergeEventFields(event, mapstr.M{"state": stateFields}) + eventext.MergeEventFields(event, mapstr.M{"state": ms}) f, _ := json.Marshal(event.Fields) logp.Info("SUMMARY %s", f) From 8bf1b0590b8b69a53be698ac749e74e0b528abdf Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 6 Jul 2022 21:23:38 -0500 Subject: [PATCH 027/102] more is working --- .../monitors/wrappers/monitorstate/monitorstate.go | 12 ++++++------ heartbeat/monitors/wrappers/monitorstate/tracker.go | 2 +- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 086e841c24ef..df3cb5671e20 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -14,7 +14,7 @@ const ( ) func NewMonitorState(monitorId string, isUp bool) *MonitorState { - startedAtMs := time.Now().UnixMilli() + startedAtMs := float64(time.Now().UnixMilli()) ms := &MonitorState{ Id: fmt.Sprintf("%s-%x", monitorId, startedAtMs), MonitorId: monitorId, @@ -30,14 +30,14 @@ func NewMonitorState(monitorId string, isUp bool) *MonitorState { } type HistoricalStatus struct { - TsMs int64 `json:"ts_ms"` - Status string `json:"status"` + TsMs float64 `json:"ts_ms"` + Status string `json:"status"` } type MonitorState struct { MonitorId string `json:"monitorId"` Id string `json:"id"` - StartedAtMs int64 `json:"started_at_ms"` + StartedAtMs float64 `json:"started_at_ms"` Status string `json:"status"` Checks int `json:"checks"` Up int `json:"up"` @@ -65,14 +65,14 @@ func (state *MonitorState) isStateStillStable(currentStatus string) bool { // flapCompute returns true if we are still flapping, false if we no longer are. func (state *MonitorState) flapCompute(currentStatus string) bool { - state.FlapHistory = append(state.FlapHistory, HistoricalStatus{time.Now().UnixMilli(), state.Status}) + state.FlapHistory = append(state.FlapHistory, HistoricalStatus{float64(time.Now().UnixMilli()), state.Status}) state.Status = currentStatus // Figure out which values are old enough that we can discard them for our calculation cutOff := time.Now().Add(-FlappingThreshold).UnixMilli() discardIndex := -1 for idx, hs := range state.FlapHistory { - if hs.TsMs < cutOff { + if int64(hs.TsMs) < cutOff { discardIndex = idx } else { break diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 2cb991f798f2..055ef1b6c0aa 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -72,7 +72,7 @@ func (mst *MonitorStateTracker) Compute(monitorId string, isUp bool) (curState * // The state is stable, no changes needed state.recordCheck(isUp) return state - } else if state.StartedAtMs > time.Now().Add(-FlappingThreshold).UnixMilli() { + } else if state.StartedAtMs > float64(time.Now().Add(-FlappingThreshold).UnixMilli()) { // The state changed too quickly, we're now flapping // TODO: is the above conditional right? state.flapCompute(currentStatus) // record the new state to the flap history From 83e26b61488af0fd43afccccbcf45329826b66b5 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 8 Aug 2022 14:48:51 -0500 Subject: [PATCH 028/102] Clean-up initialization of ES client --- dev-tools/dummy_http/main.go | 14 +++++++----- heartbeat/beater/heartbeat.go | 41 +++++++++++++++++++++-------------- 2 files changed, 34 insertions(+), 21 deletions(-) diff --git a/dev-tools/dummy_http/main.go b/dev-tools/dummy_http/main.go index 29729061d22a..296a217227d8 100644 --- a/dev-tools/dummy_http/main.go +++ b/dev-tools/dummy_http/main.go @@ -26,7 +26,7 @@ func main() { http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) { atomic.AddUint64(&reqs, 1) - writer.Write([]byte("Dummy HTTP Server")) + _, _ = writer.Write([]byte("Dummy HTTP Server")) }) http.HandleFunc("/pattern", func(writer http.ResponseWriter, request *http.Request) { @@ -34,21 +34,24 @@ func main() { status, body := handlePattern(states, request.URL) writer.WriteHeader(status) - writer.Write([]byte(body)) + _, _ = writer.Write([]byte(body)) }) go func() { for { time.Sleep(time.Second * 10) r := atomic.LoadUint64(&reqs) + // nolint forbidigo fmt.Printf("Processed %d reqs\n", r) } }() port := 5678 + // nolint forbidigo fmt.Printf("Starting server on port %d\n", port) err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil) if err != nil { + // nolint forbidigo fmt.Printf("Could not start server: %s", err) os.Exit(1) } @@ -63,6 +66,7 @@ type responsePattern struct { func (rp *responsePattern) next() (status int, body string) { var idx int if rp.httpStatusesLen > 1 { + // nolint forbidigo fmt.Printf("INTN %d\n", rp.httpStatusesLen) idx = rand.Intn(rp.httpStatusesLen) } else { @@ -83,7 +87,7 @@ type responsePatternSequence struct { func (ps *responsePatternSequence) next() (status int, body string) { ps.mtx.Lock() - ps.mtx.Unlock() + defer ps.mtx.Unlock() if ps.currentPatternCount >= ps.currentPattern.countLimit { ps.advancePattern() @@ -109,7 +113,7 @@ func (ps *responsePatternSequence) advancePattern() { ps.currentPatternCount = 0 } -var statusListRegexp = regexp.MustCompile("^[|\\d]+$") +var statusListRegexp = regexp.MustCompile(`^[|\\d]+$`) func handlePattern(states *sync.Map, url *url.URL) (status int, body string) { query := url.Query() @@ -162,7 +166,7 @@ func compilePattern(patternStr string) (*responsePattern, error) { splitPattern := strings.Split(patternStr, "x") if len(splitPattern) != 2 { - return nil, fmt.Errorf("Bad pattern '%s', expected a STATUSxCOUNT as pattern. Got %s") + return nil, fmt.Errorf("bad pattern '%s', expected a STATUSxCOUNT as pattern", patternStr) } statusDefStr := splitPattern[0] diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 0af8b48ebe36..fd2e403e03d3 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -20,6 +20,7 @@ package beater import ( "errors" "fmt" + conf "github.com/elastic/elastic-agent-libs/config" "github.com/elastic/elastic-agent-libs/logp" "github.com/elastic/go-elasticsearch/v8" @@ -60,24 +61,11 @@ type EsConfig struct { // New creates a new heartbeat. func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { - - esConfig := EsConfig{} - err := b.Config.Output.Config().Unpack(&esConfig) - + esc, err := getESClient(b.Config.Output.Config()) if err != nil { - logp.L().Info("could not unpack cloud config for heartbeat: %w", err) - } else { - esc, err := elasticsearch.NewClient(elasticsearch.Config{ - Addresses: esConfig.Hosts, - Username: esConfig.Username, - Password: esConfig.Password, - }) - if err != nil { - return nil, fmt.Errorf("could not initialize elasticsearch client: %w", err) - } - monitorstate.SetEsClient(esc) - logp.Info("successfully connected to ES for state tracking: %v", esConfig.Hosts) + return nil, err } + monitorstate.SetEsClient(esc) parsedConfig := config.DefaultConfig if err := rawConfig.Unpack(&parsedConfig); err != nil { @@ -245,3 +233,24 @@ func (bt *Heartbeat) makeAutodiscover(b *beat.Beat) (*autodiscover.Autodiscover, func (bt *Heartbeat) Stop() { close(bt.done) } + +// getESClient returns an ES client if one is configured. Will return nil, nil, if none is configured. +func getESClient(outputConfig *conf.C) (esc *elasticsearch.Client, err error) { + esConfig := EsConfig{} + err = outputConfig.Unpack(&esConfig) + if err != nil { + logp.L().Info("output is not elasticsearch, error / state tracking will not be enabled: %w", err) + return nil, nil + } + esc, err = elasticsearch.NewClient(elasticsearch.Config{ + Addresses: esConfig.Hosts, + Username: esConfig.Username, + Password: esConfig.Password, + }) + if err != nil { + return nil, fmt.Errorf("could not initialize elasticsearch client: %w", err) + } + logp.L().Infof("successfully connected to elasticsearch for error / state tracking: %v", esConfig.Hosts) + + return esc, nil +} From 844460c79e18f08d03cf47e75bff917362c841d1 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 8 Aug 2022 15:55:54 -0500 Subject: [PATCH 029/102] Many cleanups --- .../wrappers/monitorstate/monitorstate.go | 37 +++--- .../monitors/wrappers/monitorstate/tracker.go | 122 +++++++++++------- heartbeat/monitors/wrappers/wrappers.go | 7 +- 3 files changed, 98 insertions(+), 68 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index df3cb5671e20..0bb1737c2311 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -7,38 +7,37 @@ import ( const FlappingThreshold time.Duration = time.Second * 10 +type MonitorStatus string + const ( - StatusUp = "up" - StatusDown = "down" - StatusFlapping = "flap" + StatusUp MonitorStatus = "up" + StatusDown MonitorStatus = "down" + StatusFlapping MonitorStatus = "flap" ) -func NewMonitorState(monitorId string, isUp bool) *MonitorState { +func NewMonitorState(monitorId string, status MonitorStatus) *MonitorState { startedAtMs := float64(time.Now().UnixMilli()) ms := &MonitorState{ Id: fmt.Sprintf("%s-%x", monitorId, startedAtMs), MonitorId: monitorId, StartedAtMs: startedAtMs, Checks: 1, + Status: status, } - if isUp { - ms.Status = StatusUp - } else { - ms.Status = StatusDown - } + return ms } type HistoricalStatus struct { - TsMs float64 `json:"ts_ms"` - Status string `json:"status"` + TsMs float64 `json:"ts_ms"` + Status MonitorStatus `json:"status"` } type MonitorState struct { MonitorId string `json:"monitorId"` Id string `json:"id"` StartedAtMs float64 `json:"started_at_ms"` - Status string `json:"status"` + Status MonitorStatus `json:"status"` Checks int `json:"checks"` Up int `json:"up"` Down int `json:"down"` @@ -46,25 +45,25 @@ type MonitorState struct { Ends *MonitorState `json:"ends"` } -func (state *MonitorState) IsFlapping() bool { +func (state *MonitorState) isFlapping() bool { return len(state.FlapHistory) > 0 } -func (state *MonitorState) recordCheck(up bool) { +func (state *MonitorState) recordCheck(status MonitorStatus) { state.Checks++ - if up { + if status == StatusUp { state.Up++ } else { state.Down++ } } -func (state *MonitorState) isStateStillStable(currentStatus string) bool { - return state.Status == currentStatus && state.IsFlapping() +func (state *MonitorState) isStateStillStable(currentStatus MonitorStatus) bool { + return state.Status == currentStatus && state.isFlapping() } -// flapCompute returns true if we are still flapping, false if we no longer are. -func (state *MonitorState) flapCompute(currentStatus string) bool { +// wouldStatusEndFlapping returns true if the next status would end the current flapping state. +func (state *MonitorState) wouldStatusEndFlapping(currentStatus MonitorStatus) bool { state.FlapHistory = append(state.FlapHistory, HistoricalStatus{float64(time.Now().UnixMilli()), state.Status}) state.Status = currentStatus diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 055ef1b6c0aa..2830d9e6b700 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -4,14 +4,16 @@ import ( "bytes" "encoding/json" "fmt" + "math/rand" "sync" "time" - "github.com/elastic/beats/v7/heartbeat/esutil" "github.com/elastic/elastic-agent-libs/logp" "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/go-elasticsearch/v8" "github.com/elastic/go-elasticsearch/v8/esapi" + + "github.com/elastic/beats/v7/heartbeat/esutil" ) var esClient *elasticsearch.Client @@ -32,63 +34,91 @@ type MonitorStateTracker struct { mtx sync.Mutex } -func (mst *MonitorStateTracker) Compute(monitorId string, isUp bool) (curState *MonitorState) { - // If state is missing load it from ES - if _, ok := mst.states[monitorId]; !ok && esClient != nil { - loadedState, err := LoadLastState(monitorId, esClient) - if err != nil { - // TODO: What behavior do we really want here? - logp.Warn("could not load last state from elasticsearch, will create new state: %w", err) - } - - mst.states[monitorId] = loadedState - } - - currentStatus := StatusDown - if isUp { - currentStatus = StatusUp - } +func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus MonitorStatus) (urState *MonitorState) { //note: the return values have no concurrency controls, they may be unsafely read unless //copied to the stack, copying the structs before returning mst.mtx.Lock() defer mst.mtx.Unlock() - if state, ok := mst.states[monitorId]; ok { - if state.IsFlapping() { - // Check to see if there's still an ongoing flap after recording - // the new status - if state.flapCompute(currentStatus) { - state.recordCheck(isUp) - return state - } else { - state.Ends = state - newState := *NewMonitorState(monitorId, isUp) - internalNewState := newState // Copy the struct since the returned value is read after the mutex - mst.states[monitorId] = &internalNewState - return &newState - } - } else if state.Status == currentStatus { - // The state is stable, no changes needed - state.recordCheck(isUp) - return state - } else if state.StartedAtMs > float64(time.Now().Add(-FlappingThreshold).UnixMilli()) { - // The state changed too quickly, we're now flapping - // TODO: is the above conditional right? - state.flapCompute(currentStatus) // record the new state to the flap history - state.recordCheck(isUp) - return state - } + currentState, hasCurrentState := mst.states[monitorId] + + if hasCurrentState { + mst.computeNewCurrentState(currentState, newStatus, monitorId) } // No previous state, so make a new one - newState := *NewMonitorState(monitorId, isUp) + newState := *NewMonitorState(monitorId, newStatus) internalNewState := newState // Use a copy of the struct so that return values can safely be used concurrently mst.states[monitorId] = &internalNewState return &newState } -func LoadLastState(monitorId string, esc *elasticsearch.Client) (*MonitorState, error) { + +func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *MonitorState) { + if state, ok := mst.states[monitorId]; ok { + return state + } + + // If there's no ES client then we just work off memory + if esClient == nil { + return nil + } + + tries := 3 + var loadedState *MonitorState + var err error + for i := 0; i < tries; i++ { + loadedState, err = LoadLastESState(monitorId, esClient) + if err != nil { + sleepFor := (time.Duration(i*i) * time.Second) + (time.Duration(rand.Intn(500)) * time.Millisecond) + logp.L().Warnf("could not load last state from elasticsearch, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) + time.Sleep(sleepFor) + return nil + } + } + if err != nil { + logp.Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorId) + return nil + } + + // loadedState could be nil if we have no previous state history + if loadedState != nil { + mst.states[monitorId] = loadedState + } + + // Return what we found, even if nil + return loadedState +} + +func (mst *MonitorStateTracker) computeNewCurrentState(state *MonitorState, newStatus MonitorStatus, monitorId string) *MonitorState { + // If we were flapping before see if we've finally hit a steady state + if state.isFlapping() { + if state.wouldStatusEndFlapping(newStatus) { // still flapping + state.recordCheck(newStatus) + return state + } else { // the flap has ended + state.Ends = state + newState := *NewMonitorState(monitorId, newStatus) + internalNewState := newState // Copy the struct since the returned value is read after the mutex + mst.states[monitorId] = &internalNewState + return &newState + } + } else if state.Status == newStatus { // status has not changed, definitely not flapping + // The state is stable, no changes needed + state.recordCheck(newStatus) + return state + } else if state.StartedAtMs > float64(time.Now().Add(-FlappingThreshold).UnixMilli()) { + // The state changed too quickly, we're now flapping + // TODO: is the above conditional right? + state.wouldStatusEndFlapping(newStatus) // record the new state to the flap history + state.recordCheck(newStatus) + return state + } + return state +} + +func LoadLastESState(monitorId string, esc *elasticsearch.Client) (*MonitorState, error) { reqBody, err := json.Marshal(mapstr.M{ "sort": mapstr.M{"@timestamp": "desc"}, "query": mapstr.M{ @@ -138,8 +168,8 @@ func LoadLastState(monitorId string, esc *elasticsearch.Client) (*MonitorState, } if len(sh.Hits.Hits) == 0 { - logp.Info("no previous state found for monitor %s, will initialize new state", monitorId) - return NewMonitorState(monitorId, true), nil + logp.L().Infof("no previous state found for monitor %s", monitorId) + return nil, nil } return &sh.Hits.Hits[0].Source.State, nil diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index b0fed9bf147d..9ecf30e1d3c5 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -27,6 +27,9 @@ import ( "github.com/gofrs/uuid" "github.com/mitchellh/hashstructure" + "github.com/elastic/elastic-agent-libs/logp" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/eventext" "github.com/elastic/beats/v7/heartbeat/look" @@ -36,8 +39,6 @@ import ( "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/elastic/beats/v7/heartbeat/scheduler/schedule" "github.com/elastic/beats/v7/libbeat/beat" - "github.com/elastic/elastic-agent-libs/logp" - "github.com/elastic/elastic-agent-libs/mapstr" ) // WrapCommon applies the common wrappers that all monitor jobs get. @@ -99,7 +100,7 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta return nil, fmt.Errorf("could not wrap state for '%s', no status assigned: %w", sf.ID, err) } - ms := mst.Compute(sf.ID, status == "up") + ms := mst.RecordStatus(sf.ID, monitorstate.MonitorStatus(status.(string))) logp.Warn("CHECKS: %s - s:%s u:%d d:%d", sf.ID, ms.Status, ms.Up, ms.Down) From 3a1d9630ff9bc367d0653cbaacafea6c377d4067 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 8 Aug 2022 16:14:58 -0500 Subject: [PATCH 030/102] Checkpoint for flapping refactor --- .../wrappers/monitorstate/monitorstate.go | 11 ++--- .../monitorstate/monitorstate_test.go | 45 +++++++++++++++++++ .../monitors/wrappers/monitorstate/tracker.go | 4 +- 3 files changed, 51 insertions(+), 9 deletions(-) create mode 100644 heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 0bb1737c2311..eeb8354c56bd 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -5,7 +5,7 @@ import ( "time" ) -const FlappingThreshold time.Duration = time.Second * 10 +const FlappingThreshold = 3 type MonitorStatus string @@ -15,15 +15,15 @@ const ( StatusFlapping MonitorStatus = "flap" ) -func NewMonitorState(monitorId string, status MonitorStatus) *MonitorState { +func newMonitorState(monitorId string, status MonitorStatus) *MonitorState { startedAtMs := float64(time.Now().UnixMilli()) ms := &MonitorState{ Id: fmt.Sprintf("%s-%x", monitorId, startedAtMs), MonitorId: monitorId, StartedAtMs: startedAtMs, - Checks: 1, Status: status, } + ms.recordCheck(status) return ms } @@ -49,6 +49,7 @@ func (state *MonitorState) isFlapping() bool { return len(state.FlapHistory) > 0 } +// recordCheck records a new check to the stat counters only, it does not do any flap computation func (state *MonitorState) recordCheck(status MonitorStatus) { state.Checks++ if status == StatusUp { @@ -58,10 +59,6 @@ func (state *MonitorState) recordCheck(status MonitorStatus) { } } -func (state *MonitorState) isStateStillStable(currentStatus MonitorStatus) bool { - return state.Status == currentStatus && state.isFlapping() -} - // wouldStatusEndFlapping returns true if the next status would end the current flapping state. func (state *MonitorState) wouldStatusEndFlapping(currentStatus MonitorStatus) bool { state.FlapHistory = append(state.FlapHistory, HistoricalStatus{float64(time.Now().UnixMilli()), state.Status}) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go new file mode 100644 index 000000000000..8e1c35b11043 --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -0,0 +1,45 @@ +package monitorstate + +import ( + "github.com/stretchr/testify/require" + "testing" +) + +func TestIsFlappingWithFlapHistory(t *testing.T) { + ms := newMonitorState("test", StatusUp) + require.False(t, ms.isFlapping()) + + ms.FlapHistory = []HistoricalStatus{ + {TsMs: 0, Status: StatusUp}, + {TsMs: 1, Status: StatusDown}, + {TsMs: 2, Status: StatusDown}, + } + + require.True(t, ms.isFlapping()) +} + +func TestRecordingChecks(t *testing.T) { + ms := newMonitorState("test", StatusUp) + + require.Equal(t, 1, ms.Checks) + require.Equal(t, 1, ms.Up) + require.Equal(t, 0, ms.Down) + + ms.recordCheck(StatusUp) + ms.recordCheck(StatusUp) + ms.recordCheck(StatusDown) + + require.Equal(t, 4, ms.Checks) + require.Equal(t, 3, ms.Up) + require.Equal(t, 1, ms.Down) +} + +func TestWouldStatusEndFlapping(t *testing.T) { + ms := newMonitorState("test", StatusUp) + + ms.FlapHistory = []HistoricalStatus{ + {TsMs: 0, Status: StatusUp}, + {TsMs: 1000, Status: StatusDown}, + {TsMs: 2000, Status: StatusDown}, + } +} diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 2830d9e6b700..0c95872408ff 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -48,7 +48,7 @@ func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus Monitor } // No previous state, so make a new one - newState := *NewMonitorState(monitorId, newStatus) + newState := *newMonitorState(monitorId, newStatus) internalNewState := newState // Use a copy of the struct so that return values can safely be used concurrently mst.states[monitorId] = &internalNewState @@ -99,7 +99,7 @@ func (mst *MonitorStateTracker) computeNewCurrentState(state *MonitorState, newS return state } else { // the flap has ended state.Ends = state - newState := *NewMonitorState(monitorId, newStatus) + newState := *newMonitorState(monitorId, newStatus) internalNewState := newState // Copy the struct since the returned value is read after the mutex mst.states[monitorId] = &internalNewState return &newState From 21d6062efa3de9ac2ab09887a8caff5e42059ea3 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 8 Aug 2022 23:33:03 -0500 Subject: [PATCH 031/102] Checkpoint --- .../wrappers/monitorstate/monitorstate.go | 92 ++++++++++++------- .../monitors/wrappers/monitorstate/tracker.go | 47 +--------- 2 files changed, 64 insertions(+), 75 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index eeb8354c56bd..ecd1d9ec74e6 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -34,23 +34,22 @@ type HistoricalStatus struct { } type MonitorState struct { - MonitorId string `json:"monitorId"` - Id string `json:"id"` - StartedAtMs float64 `json:"started_at_ms"` - Status MonitorStatus `json:"status"` - Checks int `json:"checks"` - Up int `json:"up"` - Down int `json:"down"` - FlapHistory []HistoricalStatus `json:"flap_history"` - Ends *MonitorState `json:"ends"` + MonitorId string `json:"monitorId"` + Id string `json:"id"` + StartedAtMs float64 `json:"started_at_ms"` + Status MonitorStatus `json:"status"` + Checks int `json:"checks"` + Up int `json:"up"` + Down int `json:"down"` + FlapHistory []MonitorStatus `json:"flap_history"` + Ends *MonitorState `json:"ends"` } func (state *MonitorState) isFlapping() bool { return len(state.FlapHistory) > 0 } -// recordCheck records a new check to the stat counters only, it does not do any flap computation -func (state *MonitorState) recordCheck(status MonitorStatus) { +func (state *MonitorState) incrementCounters(status MonitorStatus) { state.Checks++ if status == StatusUp { state.Up++ @@ -59,31 +58,58 @@ func (state *MonitorState) recordCheck(status MonitorStatus) { } } -// wouldStatusEndFlapping returns true if the next status would end the current flapping state. -func (state *MonitorState) wouldStatusEndFlapping(currentStatus MonitorStatus) bool { - state.FlapHistory = append(state.FlapHistory, HistoricalStatus{float64(time.Now().UnixMilli()), state.Status}) - state.Status = currentStatus +func (state *MonitorState) truncateFlapHistoryToThreshold() { + endIdx := len(state.FlapHistory) - 1 + startIdx := endIdx - FlappingThreshold + if startIdx < 0 { + startIdx = 0 + } + state.FlapHistory = state.FlapHistory[startIdx:endIdx] +} - // Figure out which values are old enough that we can discard them for our calculation - cutOff := time.Now().Add(-FlappingThreshold).UnixMilli() - discardIndex := -1 - for idx, hs := range state.FlapHistory { - if int64(hs.TsMs) < cutOff { - discardIndex = idx - } else { - break +// recordCheck records a new check to the stat counters only, it does not do any flap computation +func (state *MonitorState) recordCheck(newStatus MonitorStatus) { + if state.isFlapping() { + newFlapHistory := append(state.FlapHistory, newStatus) + var lastStatus MonitorStatus + isStable := true + for _, histStatus := range newFlapHistory { + if lastStatus != histStatus { + isStable = false + break + } + lastStatus = histStatus } - } - // Do the discarding - if discardIndex != -1 { - state.FlapHistory = state.FlapHistory[discardIndex+1:] - } - // Check to see if we are no longer flapping, and if so clear flap history - for _, hs := range state.FlapHistory { - if hs.Status != currentStatus { - return false + if !isStable { // continue flapping + // Use the new flap history as part of the state + state.FlapHistory = newFlapHistory + state.incrementCounters(newStatus) + } else { // flap has ended + oldState := *state + state = newMonitorState(state.MonitorId, newStatus) + state.Ends = &oldState } + } else if state.Status == newStatus { // stable state, status has not changed + // The state is stable, no changes needed + state.incrementCounters(newStatus) + } else if state.Checks < FlappingThreshold { + // The state changed too quickly, we're now flapping + state.incrementCounters(newStatus) + state.FlapHistory = append(state.FlapHistory, newStatus) + } else { + // state has changed, but we aren't flapping (yet), since we've been stable past the + // flapping threshold + oldState := *state + state = newMonitorState(state.MonitorId, newStatus) + state.Ends = &oldState } - return true +} + +// copy returns a threadsafe copy since the instance used in the tracker is frequently mutated +func (state *MonitorState) copy() *MonitorState { + copied := *state + copied.FlapHistory = make([]MonitorStatus, len(state.FlapHistory)) + copy(copied.FlapHistory, state.FlapHistory) + return &copied } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 0c95872408ff..9637005f291d 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -35,24 +35,14 @@ type MonitorStateTracker struct { } func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus MonitorStatus) (urState *MonitorState) { - //note: the return values have no concurrency controls, they may be unsafely read unless //copied to the stack, copying the structs before returning mst.mtx.Lock() defer mst.mtx.Unlock() - currentState, hasCurrentState := mst.states[monitorId] - - if hasCurrentState { - mst.computeNewCurrentState(currentState, newStatus, monitorId) - } - - // No previous state, so make a new one - newState := *newMonitorState(monitorId, newStatus) - internalNewState := newState - // Use a copy of the struct so that return values can safely be used concurrently - mst.states[monitorId] = &internalNewState - return &newState + state := mst.getCurrentState(monitorId) + state.recordCheck(newStatus) + return state.copy() } func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *MonitorState) { @@ -69,7 +59,7 @@ func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *Monito var loadedState *MonitorState var err error for i := 0; i < tries; i++ { - loadedState, err = LoadLastESState(monitorId, esClient) + loadedState, err = loadLastESState(monitorId, esClient) if err != nil { sleepFor := (time.Duration(i*i) * time.Second) + (time.Duration(rand.Intn(500)) * time.Millisecond) logp.L().Warnf("could not load last state from elasticsearch, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) @@ -91,34 +81,7 @@ func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *Monito return loadedState } -func (mst *MonitorStateTracker) computeNewCurrentState(state *MonitorState, newStatus MonitorStatus, monitorId string) *MonitorState { - // If we were flapping before see if we've finally hit a steady state - if state.isFlapping() { - if state.wouldStatusEndFlapping(newStatus) { // still flapping - state.recordCheck(newStatus) - return state - } else { // the flap has ended - state.Ends = state - newState := *newMonitorState(monitorId, newStatus) - internalNewState := newState // Copy the struct since the returned value is read after the mutex - mst.states[monitorId] = &internalNewState - return &newState - } - } else if state.Status == newStatus { // status has not changed, definitely not flapping - // The state is stable, no changes needed - state.recordCheck(newStatus) - return state - } else if state.StartedAtMs > float64(time.Now().Add(-FlappingThreshold).UnixMilli()) { - // The state changed too quickly, we're now flapping - // TODO: is the above conditional right? - state.wouldStatusEndFlapping(newStatus) // record the new state to the flap history - state.recordCheck(newStatus) - return state - } - return state -} - -func LoadLastESState(monitorId string, esc *elasticsearch.Client) (*MonitorState, error) { +func loadLastESState(monitorId string, esc *elasticsearch.Client) (*MonitorState, error) { reqBody, err := json.Marshal(mapstr.M{ "sort": mapstr.M{"@timestamp": "desc"}, "query": mapstr.M{ From 26eac4e90ef61babca52e33f8efb5a3ed8b08f93 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 9 Aug 2022 22:25:08 -0500 Subject: [PATCH 032/102] Fix tracker, add basic tracker tests, plus type for loading past state. --- .../wrappers/monitorstate/monitorstate.go | 122 +++++++++--------- .../monitorstate/monitorstate_test.go | 64 ++++----- .../monitors/wrappers/monitorstate/tracker.go | 54 +++++--- .../wrappers/monitorstate/tracker_test.go | 30 +++++ heartbeat/monitors/wrappers/wrappers.go | 2 +- 5 files changed, 165 insertions(+), 107 deletions(-) create mode 100644 heartbeat/monitors/wrappers/monitorstate/tracker_test.go diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index ecd1d9ec74e6..9fc49e4a7809 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -7,15 +7,15 @@ import ( const FlappingThreshold = 3 -type MonitorStatus string +type StateStatus string const ( - StatusUp MonitorStatus = "up" - StatusDown MonitorStatus = "down" - StatusFlapping MonitorStatus = "flap" + StatusUp StateStatus = "up" + StatusDown StateStatus = "down" + StatusFlapping StateStatus = "flap" ) -func newMonitorState(monitorId string, status MonitorStatus) *MonitorState { +func newMonitorState(monitorId string, status StateStatus) *MonitorState { startedAtMs := float64(time.Now().UnixMilli()) ms := &MonitorState{ Id: fmt.Sprintf("%s-%x", monitorId, startedAtMs), @@ -29,87 +29,93 @@ func newMonitorState(monitorId string, status MonitorStatus) *MonitorState { } type HistoricalStatus struct { - TsMs float64 `json:"ts_ms"` - Status MonitorStatus `json:"status"` + TsMs float64 `json:"ts_ms"` + Status StateStatus `json:"status"` } type MonitorState struct { - MonitorId string `json:"monitorId"` - Id string `json:"id"` - StartedAtMs float64 `json:"started_at_ms"` - Status MonitorStatus `json:"status"` - Checks int `json:"checks"` - Up int `json:"up"` - Down int `json:"down"` - FlapHistory []MonitorStatus `json:"flap_history"` - Ends *MonitorState `json:"ends"` + MonitorId string `json:"monitorId"` + Id string `json:"id"` + StartedAtMs float64 `json:"started_at_ms"` + Status StateStatus `json:"status"` + Checks int `json:"checks"` + Up int `json:"up"` + Down int `json:"down"` + FlapHistory []StateStatus `json:"flap_history"` + Ends *MonitorState `json:"ends"` } -func (state *MonitorState) isFlapping() bool { - return len(state.FlapHistory) > 0 -} - -func (state *MonitorState) incrementCounters(status MonitorStatus) { - state.Checks++ +func (ms *MonitorState) incrementCounters(status StateStatus) { + ms.Checks++ if status == StatusUp { - state.Up++ + ms.Up++ } else { - state.Down++ + ms.Down++ } } -func (state *MonitorState) truncateFlapHistoryToThreshold() { - endIdx := len(state.FlapHistory) - 1 - startIdx := endIdx - FlappingThreshold - if startIdx < 0 { - startIdx = 0 +// truncate flap history to be at most as many items as the threshold indicates, minus one +func (ms *MonitorState) truncateFlapHistory() { + endIdx := len(ms.FlapHistory) + if endIdx < 0 { + return // flap history is empty } - state.FlapHistory = state.FlapHistory[startIdx:endIdx] + // truncate to one less than the threshold since our later calculations + // an item that would stabilize the history at the threshold would start a new state + startIdx := endIdx - (FlappingThreshold - 1) + if startIdx <= 0 { + return + } + ms.FlapHistory = ms.FlapHistory[startIdx:endIdx] } -// recordCheck records a new check to the stat counters only, it does not do any flap computation -func (state *MonitorState) recordCheck(newStatus MonitorStatus) { - if state.isFlapping() { - newFlapHistory := append(state.FlapHistory, newStatus) - var lastStatus MonitorStatus - isStable := true - for _, histStatus := range newFlapHistory { - if lastStatus != histStatus { - isStable = false +// recordCheck updates the current state pointer to what the new state should be. +// If the current state is continued it just updates counters and other record keeping, +// if the state ends it actually swaps out the full value the state points to +// and sets state.Ends. +func (ms *MonitorState) recordCheck(newStatus StateStatus) { + if ms.Status == StatusFlapping { + ms.truncateFlapHistory() + + // Check if all statuses in flap history are identical, including the new status + hasStabilized := true + for _, histStatus := range ms.FlapHistory { + if newStatus != histStatus { + hasStabilized = false break } - lastStatus = histStatus } - if !isStable { // continue flapping + if !hasStabilized { // continue flapping // Use the new flap history as part of the state - state.FlapHistory = newFlapHistory - state.incrementCounters(newStatus) + ms.FlapHistory = append(ms.FlapHistory, newStatus) + ms.incrementCounters(newStatus) } else { // flap has ended - oldState := *state - state = newMonitorState(state.MonitorId, newStatus) - state.Ends = &oldState + oldState := *ms + *ms = *newMonitorState(ms.MonitorId, newStatus) + ms.Ends = &oldState } - } else if state.Status == newStatus { // stable state, status has not changed + } else if ms.Status == newStatus { // stable state, status has not changed // The state is stable, no changes needed - state.incrementCounters(newStatus) - } else if state.Checks < FlappingThreshold { + ms.incrementCounters(newStatus) + } else if ms.Checks < FlappingThreshold { // The state changed too quickly, we're now flapping - state.incrementCounters(newStatus) - state.FlapHistory = append(state.FlapHistory, newStatus) + ms.incrementCounters(newStatus) + ms.Status = StatusFlapping + ms.FlapHistory = append(ms.FlapHistory, newStatus) } else { // state has changed, but we aren't flapping (yet), since we've been stable past the // flapping threshold - oldState := *state - state = newMonitorState(state.MonitorId, newStatus) - state.Ends = &oldState + oldState := *ms + *ms = *newMonitorState(ms.MonitorId, newStatus) + ms.Ends = &oldState } } // copy returns a threadsafe copy since the instance used in the tracker is frequently mutated -func (state *MonitorState) copy() *MonitorState { - copied := *state - copied.FlapHistory = make([]MonitorStatus, len(state.FlapHistory)) - copy(copied.FlapHistory, state.FlapHistory) +func (ms *MonitorState) copy() *MonitorState { + copied := *ms + copied.FlapHistory = make([]StateStatus, len(ms.FlapHistory)) + copy(copied.FlapHistory, ms.FlapHistory) return &copied } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index 8e1c35b11043..15dfd657b0c7 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -5,41 +5,47 @@ import ( "testing" ) -func TestIsFlappingWithFlapHistory(t *testing.T) { +func TestRecordingAndFlapping(t *testing.T) { ms := newMonitorState("test", StatusUp) - require.False(t, ms.isFlapping()) - - ms.FlapHistory = []HistoricalStatus{ - {TsMs: 0, Status: StatusUp}, - {TsMs: 1, Status: StatusDown}, - {TsMs: 2, Status: StatusDown}, - } - - require.True(t, ms.isFlapping()) -} - -func TestRecordingChecks(t *testing.T) { - ms := newMonitorState("test", StatusUp) - + recordFlappingSeries(ms) + require.Equal(t, StatusFlapping, ms.Status) + require.Equal(t, FlappingThreshold+1, ms.Checks) + require.Equal(t, ms.Up+ms.Down, ms.Checks) + + // Use double the flapping threshold so any transitions after this are stable + priorChecksCount := ms.Checks + recordStableSeries(ms, FlappingThreshold*2, StatusDown) + require.Equal(t, StatusDown, ms.Status) + // The count should be FlappingThreshold+1 since we used double the threshold before + // This is because we have one full threshold of stable checks, as well as the final check that + // flipped us out of the threshold, which goes toward the new state. + require.Equal(t, FlappingThreshold+1, ms.Checks) + require.Equal(t, 0, ms.Up) + require.Equal(t, FlappingThreshold+1, ms.Down) + require.Equal(t, priorChecksCount+FlappingThreshold-1, ms.Ends.Checks) + + // Since we're now in a stable state a single up check should create a new state from a stable one + ms.recordCheck(StatusUp) + require.Equal(t, StatusUp, ms.Status) require.Equal(t, 1, ms.Checks) require.Equal(t, 1, ms.Up) require.Equal(t, 0, ms.Down) - - ms.recordCheck(StatusUp) - ms.recordCheck(StatusUp) - ms.recordCheck(StatusDown) - - require.Equal(t, 4, ms.Checks) - require.Equal(t, 3, ms.Up) - require.Equal(t, 1, ms.Down) } -func TestWouldStatusEndFlapping(t *testing.T) { - ms := newMonitorState("test", StatusUp) +// recordFlappingSeries is a helper that should always put the monitor into a flapping state. +func recordFlappingSeries(ms *MonitorState) { + for i := 0; i < FlappingThreshold; i++ { + if i%2 == 0 { + ms.recordCheck(StatusUp) + } else { + ms.recordCheck(StatusDown) + } + } +} - ms.FlapHistory = []HistoricalStatus{ - {TsMs: 0, Status: StatusUp}, - {TsMs: 1000, Status: StatusDown}, - {TsMs: 2000, Status: StatusDown}, +// recordStableSeries is a test helper for repeatedly recording one status +func recordStableSeries(ms *MonitorState, count int, s StateStatus) { + for i := 0; i < count; i++ { + ms.recordCheck(s) } } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 9637005f291d..4fceae2c546f 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -23,25 +23,41 @@ func SetEsClient(c *elasticsearch.Client) { } func NewMonitorStateTracker() *MonitorStateTracker { - return &MonitorStateTracker{ - states: map[string]*MonitorState{}, - mtx: sync.Mutex{}, + mst := &MonitorStateTracker{ + states: map[string]*MonitorState{}, + mtx: sync.Mutex{}, + stateLoader: NilStateLoader, } + if esClient != nil { + mst.stateLoader = LoadLastESState + } + return mst } type MonitorStateTracker struct { - states map[string]*MonitorState - mtx sync.Mutex + states map[string]*MonitorState + mtx sync.Mutex + stateLoader StateLoader } -func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus MonitorStatus) (urState *MonitorState) { +// StateLoader has signature as loadLastESState, useful for test mocking, and maybe for a future impl +// other than ES if necessary +type StateLoader func(monitorId string) (*MonitorState, error) + +func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus StateStatus) (ms *MonitorState) { //note: the return values have no concurrency controls, they may be unsafely read unless //copied to the stack, copying the structs before returning mst.mtx.Lock() defer mst.mtx.Unlock() state := mst.getCurrentState(monitorId) - state.recordCheck(newStatus) + if state == nil { + state = newMonitorState(monitorId, newStatus) + mst.states[monitorId] = state + } else { + state.recordCheck(newStatus) + } + // return a copy since the state itself is a pointer that is frequently mutated return state.copy() } @@ -59,29 +75,29 @@ func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *Monito var loadedState *MonitorState var err error for i := 0; i < tries; i++ { - loadedState, err = loadLastESState(monitorId, esClient) + loadedState, err = mst.stateLoader(monitorId) if err != nil { sleepFor := (time.Duration(i*i) * time.Second) + (time.Duration(rand.Intn(500)) * time.Millisecond) - logp.L().Warnf("could not load last state from elasticsearch, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) + logp.L().Warnf("could not load last externally recorded state, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) time.Sleep(sleepFor) - return nil } } if err != nil { - logp.Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorId) - return nil - } - - // loadedState could be nil if we have no previous state history - if loadedState != nil { - mst.states[monitorId] = loadedState + logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorId) } // Return what we found, even if nil return loadedState } -func loadLastESState(monitorId string, esc *elasticsearch.Client) (*MonitorState, error) { +// NilStateLoader always returns nil, nil. It's the default when no ES conn is available +// or during testing +func NilStateLoader(_ string) (*MonitorState, error) { + return nil, nil +} + +// LoadLastESState attempts to find a matching prior state in Elasticsearch. If none, returns nil, nil +func LoadLastESState(monitorId string) (*MonitorState, error) { reqBody, err := json.Marshal(mapstr.M{ "sort": mapstr.M{"@timestamp": "desc"}, "query": mapstr.M{ @@ -101,7 +117,7 @@ func loadLastESState(monitorId string, esc *elasticsearch.Client) (*MonitorState return nil, fmt.Errorf("could not serialize query for state save: %w", err) } - r, err := esc.Search(func(sr *esapi.SearchRequest) { + r, err := esClient.Search(func(sr *esapi.SearchRequest) { sr.Index = []string{"synthetics-*"} size := 1 sr.Size = &size diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go new file mode 100644 index 000000000000..ae8931bc1841 --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -0,0 +1,30 @@ +package monitorstate + +import ( + "github.com/stretchr/testify/require" + "testing" +) + +func TestTrackerRecord(t *testing.T) { + monId := "mymonitor" + mst := NewMonitorStateTracker() + ms := mst.RecordStatus(monId, StatusUp) + require.Equal(t, StatusUp, ms.Status) + require.Equal(t, 1, ms.Checks) + require.Equal(t, 1, ms.Up) + require.Equal(t, 0, ms.Down) + + for i := 0; i < FlappingThreshold; i++ { + ms = mst.RecordStatus(monId, StatusUp) + } + require.Equal(t, StatusUp, ms.Status) + require.Equal(t, 4, ms.Checks) + require.Equal(t, 4, ms.Up) + require.Equal(t, 0, ms.Down) + + ms = mst.RecordStatus(monId, StatusDown) + require.Equal(t, StatusDown, ms.Status) + require.Equal(t, 1, ms.Checks) + require.Equal(t, 0, ms.Up) + require.Equal(t, 1, ms.Down) +} diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 9ecf30e1d3c5..655fcde1837b 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -100,7 +100,7 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorSta return nil, fmt.Errorf("could not wrap state for '%s', no status assigned: %w", sf.ID, err) } - ms := mst.RecordStatus(sf.ID, monitorstate.MonitorStatus(status.(string))) + ms := mst.RecordStatus(sf.ID, monitorstate.StateStatus(status.(string))) logp.Warn("CHECKS: %s - s:%s u:%d d:%d", sf.ID, ms.Status, ms.Up, ms.Down) From 5fdba6cc13ff552997a89343ce0656177895d4d3 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 10 Aug 2022 20:09:05 -0500 Subject: [PATCH 033/102] Checkpoint --- x-pack/heartbeat/docker-compose.yml | 19 +++++++++++++++++++ x-pack/heartbeat/magefile.go | 6 ++++++ .../browser/synthexec/synthexec_test.go | 5 ++--- 3 files changed, 27 insertions(+), 3 deletions(-) create mode 100644 x-pack/heartbeat/docker-compose.yml diff --git a/x-pack/heartbeat/docker-compose.yml b/x-pack/heartbeat/docker-compose.yml new file mode 100644 index 000000000000..bed468effa80 --- /dev/null +++ b/x-pack/heartbeat/docker-compose.yml @@ -0,0 +1,19 @@ +version: '2.3' +services: + # This is a proxy used to block beats until all services are healthy. + # See: https://github.com/docker/compose/issues/4369 + proxy_dep: + image: busybox + depends_on: + elasticsearch: { condition: service_healthy } + + elasticsearch: + extends: + file: ${ES_BEATS}/testing/environments/${STACK_ENVIRONMENT}.yml + service: elasticsearch + healthcheck: + test: ["CMD-SHELL", "curl -u admin:testing -s http://localhost:9200/_cat/health?h=status | grep -q green"] + retries: 300 + interval: 1s + ports: + - 9200:9200 diff --git a/x-pack/heartbeat/magefile.go b/x-pack/heartbeat/magefile.go index 9f7fa4375b17..804fcf773de3 100644 --- a/x-pack/heartbeat/magefile.go +++ b/x-pack/heartbeat/magefile.go @@ -8,6 +8,7 @@ package main import ( + "context" "fmt" "os" "time" @@ -76,6 +77,11 @@ func Update() { mg.SerialDeps(Fields, FieldDocs, Config) } +func HintegTest() error { + fmt.Println("Running heartbeat go integ tests") + return devtools.GoIntegTestFromHost(context.Background(), devtools.DefaultGoTestIntegrationFromHostArgs()) +} + func Fields() error { return heartbeat.Fields() } diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go b/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go index 544b58fc2c88..1bffc1ecb7b8 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthexec_test.go @@ -9,7 +9,6 @@ import ( "fmt" "os" "os/exec" - "path" "path/filepath" "runtime" "testing" @@ -215,10 +214,10 @@ func eventsWithType(typ string, synthEvents []*SynthEvent) (matched []*SynthEven func TestProjectCommandFactory(t *testing.T) { _, filename, _, _ := runtime.Caller(0) - origPath := path.Join(filepath.Dir(filename), "../source/fixtures/todos") + origPath := filepath.Join(filepath.Dir(filename), "..", "source", "fixtures", "todos") projectPath, err := filepath.Abs(origPath) require.NoError(t, err) - binPath := path.Join(projectPath, "node_modules/.bin/elastic-synthetics") + binPath := filepath.Join(projectPath, "node_modules", ".bin", "elastic-synthetics") tests := []struct { name string From 4da0d7e78dd2473eaa5f885dc9d764b2163b0146 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 10 Aug 2022 21:31:06 -0500 Subject: [PATCH 034/102] Checkpoint --- .../scenarios/es_integration_test.go | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 x-pack/heartbeat/scenarios/es_integration_test.go diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go new file mode 100644 index 000000000000..41ae6d44d600 --- /dev/null +++ b/x-pack/heartbeat/scenarios/es_integration_test.go @@ -0,0 +1,20 @@ +package scenarios + +import ( + "fmt" + "github.com/elastic/go-elasticsearch/v8" + "github.com/stretchr/testify/require" + "testing" +) + +func TestStates(t *testing.T) { + esc, err := elasticsearch.NewClient(elasticsearch.Config{ + Addresses: []string{"127.0.0.1:9200"}, + Username: "elastic", + Password: "changeme", + }) + require.NoError(t, err) + h, err := esc.Cluster.Health() + require.NoError(t, err) + fmt.Printf("BODY %v", h.Body) +} From 6f4c20a717170d22818cdfe379222adecf572738 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 17:15:13 -0500 Subject: [PATCH 035/102] ES kinda works in testing. --- dev-tools/mage/integtest_docker.go | 4 + .../wrappers/monitorstate/esloader.go | 80 ++++++++++++++ .../monitorstate/esloader_integration_test.go | 100 ++++++++++++++++++ .../wrappers/monitorstate/monitorstate.go | 6 +- .../monitors/wrappers/monitorstate/tracker.go | 84 ++------------- .../wrappers/monitorstate/tracker_test.go | 2 +- heartbeat/monitors/wrappers/wrappers.go | 2 +- .../integ test x-pack_heartbeat.run.xml | 13 +++ .../monitors/browser/source/zipurl_test.go | 4 +- .../browser/synthexec/execmultiplexer.go | 10 +- .../scenarios/es_integration_test.go | 15 +-- 11 files changed, 223 insertions(+), 97 deletions(-) create mode 100644 heartbeat/monitors/wrappers/monitorstate/esloader.go create mode 100644 heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go create mode 100644 x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml diff --git a/dev-tools/mage/integtest_docker.go b/dev-tools/mage/integtest_docker.go index 8c5fb6d3603f..74e35070d30b 100644 --- a/dev-tools/mage/integtest_docker.go +++ b/dev-tools/mage/integtest_docker.go @@ -230,8 +230,11 @@ func GoIntegTestFromHost(ctx context.Context, params GoTestArgs) error { return fmt.Errorf("starting containers: %w", err) } + fmt.Println("RUN THE THING") // Run Go test from the host machine. Do not immediately exit on error to allow cleanup to occur. + params.ExtraFlags = append(params.ExtraFlags, "-v") testErr := GoTest(ctx, params) + fmt.Println("RUNDONE") err = saveDockerComposeLogs(cwd, "goIntegTest") if err != nil { @@ -239,6 +242,7 @@ func GoIntegTestFromHost(ctx context.Context, params GoTestArgs) error { fmt.Printf("Failed to save docker-compose logs: %s\n", err) } + fmt.Println("STOPITALL") err = StopIntegTestContainers() if err != nil && testErr == nil { // Stopping containers failed but the test didn't diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader.go b/heartbeat/monitors/wrappers/monitorstate/esloader.go new file mode 100644 index 000000000000..470a62f6ac98 --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/esloader.go @@ -0,0 +1,80 @@ +package monitorstate + +import ( + "bytes" + "encoding/json" + "fmt" + "github.com/elastic/elastic-agent-libs/logp" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/go-elasticsearch/v8" + "github.com/elastic/go-elasticsearch/v8/esapi" + + "github.com/elastic/beats/v7/heartbeat/esutil" +) + +func MakeESLoader(esc *elasticsearch.Client, indexPattern string) StateLoader { + if indexPattern == "" { + indexPattern = "synthetics-*" + } + return func(monitorId string) (*MonitorState, error) { + reqBody, err := json.Marshal(mapstr.M{ + "sort": mapstr.M{"@timestamp": "desc"}, + "query": mapstr.M{ + "bool": mapstr.M{ + "must": []mapstr.M{ + { + "match": mapstr.M{"monitor.id": monitorId}, + }, + { + "exists": mapstr.M{"field": "state"}, + }, + { + // Only search the past 6h of data for perf, otherwise we reset the state + // Monitors should run more frequently than that. + "range": mapstr.M{"@timestamp": mapstr.M{"gt": "now-6h"}}, + }, + }, + }, + }, + }) + if err != nil { + return nil, fmt.Errorf("could not serialize query for state save: %w", err) + } + + r, err := esc.Search(func(sr *esapi.SearchRequest) { + sr.Index = []string{indexPattern} + size := 1 + sr.Size = &size + sr.Body = bytes.NewReader(reqBody) + }) + + type stateHits struct { + Hits struct { + Hits []struct { + DocId string `json:"string"` + Source struct { + State MonitorState `json:"state"` + } `json:"_source"` + } `json:"hits"` + } `json:"hits"` + } + + respBody, err := esutil.CheckRetResp(r, err) + if err != nil { + return nil, fmt.Errorf("error executing state search for %s: %w", monitorId, err) + } + + sh := stateHits{} + err = json.Unmarshal(respBody, &sh) + if err != nil { + return nil, fmt.Errorf("could not unmarshal state hits for %s: %w", monitorId, err) + } + + if len(sh.Hits.Hits) == 0 { + logp.L().Infof("no previous state found for monitor %s", monitorId) + return nil, nil + } + + return &sh.Hits.Hits[0].Source.State, nil + } +} diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go new file mode 100644 index 000000000000..02a8d6fd726e --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -0,0 +1,100 @@ +package monitorstate + +import ( + "encoding/json" + "fmt" + "github.com/elastic/go-elasticsearch/v8" + "github.com/elastic/go-elasticsearch/v8/esapi" + "github.com/gofrs/uuid" + "github.com/stretchr/testify/require" + "sync" + "testing" + "time" + + "github.com/elastic/beats/v7/heartbeat/esutil" +) + +func TestStates(t *testing.T) { + tc := newESTestContext(t) + + m1idUUID, _ := uuid.NewV4() + m1ID := m1idUUID.String() + m1Typ := "testtyp" + initState := newMonitorState(m1ID, StatusUp) + tc.setInitialState(t, m1Typ, initState) + ms := tc.tracker.RecordStatus(m1ID, StatusUp) + require.Equal(t, 2, ms.Checks) +} + +type esTestContext struct { + namespace string + esc *elasticsearch.Client + loader StateLoader + tracker *MonitorStateTracker +} + +func newESTestContext(t *testing.T) *esTestContext { + namespace, _ := uuid.NewV4() + esc := integES(t) + etc := &esTestContext{ + namespace: namespace.String(), + esc: esc, + loader: MakeESLoader(esc, fmt.Sprintf("synthetics-*-%s", namespace.String())), + } + + etc.tracker = NewMonitorStateTracker(etc.loader) + + return etc +} + +func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *MonitorState) { + idx := fmt.Sprintf("synthetics-%s-%s", typ, etc.namespace) + + type Mon struct { + Id string `json:"id"` + Type string `json:"type"` + } + + reqBodyRdr, err := esutil.ToJsonRdr(struct { + Ts time.Time `json:"@timestamp"` + Monitor Mon `json:"monitor"` + State *MonitorState `json:"state"` + }{ + Ts: time.Now(), + Monitor: Mon{Id: ms.MonitorId, Type: typ}, + State: ms, + }) + + _, err = esutil.CheckRetResp(etc.esc.Index(idx, reqBodyRdr, func(request *esapi.IndexRequest) { + // Refresh the index since we tend to re-query immediately, otherwise this would miss + request.Refresh = "true" + + })) + require.NoError(t, err) +} + +var connOnce = &sync.Once{} + +func integES(t *testing.T) (esc *elasticsearch.Client) { + connOnce.Do(func() { + var err error + esc, err = elasticsearch.NewClient(elasticsearch.Config{ + Addresses: []string{"http://127.0.0.1:9200"}, + Username: "admin", + Password: "testing", + }) + require.NoError(t, err) + respBody, err := esc.Cluster.Health() + healthRaw, err := esutil.CheckRetResp(respBody, err) + require.NoError(t, err) + + healthResp := struct { + Status string `json:"status"` + }{} + err = json.Unmarshal(healthRaw, &healthResp) + require.NoError(t, err) + require.Contains(t, []string{"green", "yellow"}, healthResp.Status) + }) + + return esc +} diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 9fc49e4a7809..dc19376f535c 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -16,11 +16,11 @@ const ( ) func newMonitorState(monitorId string, status StateStatus) *MonitorState { - startedAtMs := float64(time.Now().UnixMilli()) + nowMillis := time.Now().UnixMilli() ms := &MonitorState{ - Id: fmt.Sprintf("%s-%x", monitorId, startedAtMs), + Id: fmt.Sprintf("%s-%x", monitorId, nowMillis), MonitorId: monitorId, - StartedAtMs: startedAtMs, + StartedAtMs: float64(nowMillis), Status: status, } ms.recordCheck(status) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 4fceae2c546f..a96d4f5c8158 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -1,19 +1,12 @@ package monitorstate import ( - "bytes" - "encoding/json" - "fmt" "math/rand" "sync" "time" "github.com/elastic/elastic-agent-libs/logp" - "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/go-elasticsearch/v8" - "github.com/elastic/go-elasticsearch/v8/esapi" - - "github.com/elastic/beats/v7/heartbeat/esutil" ) var esClient *elasticsearch.Client @@ -22,14 +15,22 @@ func SetEsClient(c *elasticsearch.Client) { esClient = c } -func NewMonitorStateTracker() *MonitorStateTracker { +// NewMonitorStateTracker tracks state across job runs. It takes an optional +// state loader, which will try to fetch the last known state for a never +// before seen monitor, which usually means using ES. If set to nil +// it will use ES if configured, otherwise it will only track state from +// memory. +func NewMonitorStateTracker(sl StateLoader) *MonitorStateTracker { mst := &MonitorStateTracker{ states: map[string]*MonitorState{}, mtx: sync.Mutex{}, - stateLoader: NilStateLoader, + stateLoader: sl, } if esClient != nil { - mst.stateLoader = LoadLastESState + mst.stateLoader = MakeESLoader(esClient, "") + } + if mst.stateLoader == nil { + mst.stateLoader = NilStateLoader } return mst } @@ -66,11 +67,6 @@ func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *Monito return state } - // If there's no ES client then we just work off memory - if esClient == nil { - return nil - } - tries := 3 var loadedState *MonitorState var err error @@ -95,61 +91,3 @@ func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *Monito func NilStateLoader(_ string) (*MonitorState, error) { return nil, nil } - -// LoadLastESState attempts to find a matching prior state in Elasticsearch. If none, returns nil, nil -func LoadLastESState(monitorId string) (*MonitorState, error) { - reqBody, err := json.Marshal(mapstr.M{ - "sort": mapstr.M{"@timestamp": "desc"}, - "query": mapstr.M{ - "bool": mapstr.M{ - "must": []mapstr.M{ - { - "match": mapstr.M{"monitor.id": monitorId}, - }, - { - "exists": mapstr.M{"field": "summary"}, - }, - }, - }, - }, - }) - if err != nil { - return nil, fmt.Errorf("could not serialize query for state save: %w", err) - } - - r, err := esClient.Search(func(sr *esapi.SearchRequest) { - sr.Index = []string{"synthetics-*"} - size := 1 - sr.Size = &size - sr.Body = bytes.NewReader(reqBody) - }) - - type stateHits struct { - Hits struct { - Hits []struct { - DocId string `json:"string"` - Source struct { - State MonitorState `json:"state"` - } `json:"_source"` - } `json:"hits"` - } `json:"hits"` - } - - respBody, err := esutil.CheckRetResp(r, err) - if err != nil { - return nil, fmt.Errorf("error executing state search for %s: %w", monitorId, err) - } - - sh := stateHits{} - err = json.Unmarshal(respBody, &sh) - if err != nil { - return nil, fmt.Errorf("could not unmarshal state hits for %s: %w", monitorId, err) - } - - if len(sh.Hits.Hits) == 0 { - logp.L().Infof("no previous state found for monitor %s", monitorId) - return nil, nil - } - - return &sh.Hits.Hits[0].Source.State, nil -} diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index ae8931bc1841..a2f02da87c67 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -7,7 +7,7 @@ import ( func TestTrackerRecord(t *testing.T) { monId := "mymonitor" - mst := NewMonitorStateTracker() + mst := NewMonitorStateTracker(NilStateLoader) ms := mst.RecordStatus(monId, StatusUp) require.Equal(t, StatusUp, ms.Status) require.Equal(t, 1, ms.Checks) diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 655fcde1837b..58fbdb3ab4c0 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -43,7 +43,7 @@ import ( // WrapCommon applies the common wrappers that all monitor jobs get. func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields) []jobs.Job { - mst := monitorstate.NewMonitorStateTracker() + mst := monitorstate.NewMonitorStateTracker(nil) if stdMonFields.Type == "browser" { return WrapBrowser(js, stdMonFields, mst) } else { diff --git a/x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml b/x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml new file mode 100644 index 000000000000..23806757d409 --- /dev/null +++ b/x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml @@ -0,0 +1,13 @@ + + + + + + + + + + \ No newline at end of file diff --git a/x-pack/heartbeat/monitors/browser/source/zipurl_test.go b/x-pack/heartbeat/monitors/browser/source/zipurl_test.go index 6f6da1f159ac..7078436f14a8 100644 --- a/x-pack/heartbeat/monitors/browser/source/zipurl_test.go +++ b/x-pack/heartbeat/monitors/browser/source/zipurl_test.go @@ -1,6 +1,7 @@ // 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 source @@ -17,9 +18,10 @@ import ( "github.com/stretchr/testify/require" "gopkg.in/yaml.v2" - "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser/source/fixtures" "github.com/elastic/elastic-agent-libs/config" "github.com/elastic/elastic-agent-libs/mapstr" + + "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser/source/fixtures" ) func TestSimpleCases(t *testing.T) { diff --git a/x-pack/heartbeat/monitors/browser/synthexec/execmultiplexer.go b/x-pack/heartbeat/monitors/browser/synthexec/execmultiplexer.go index 77d44846a4d5..b22e49e49450 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/execmultiplexer.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/execmultiplexer.go @@ -14,11 +14,11 @@ type ExecMultiplexer struct { done chan struct{} } -func (e ExecMultiplexer) Close() { +func (e *ExecMultiplexer) Close() { close(e.synthEvents) } -func (e ExecMultiplexer) writeSynthEvent(se *SynthEvent) { +func (e *ExecMultiplexer) writeSynthEvent(se *SynthEvent) { if se == nil { // we skip writing nil events, since a nil means we're done return } @@ -32,17 +32,17 @@ func (e ExecMultiplexer) writeSynthEvent(se *SynthEvent) { } // SynthEvents returns a read only channel for synth events -func (e ExecMultiplexer) SynthEvents() <-chan *SynthEvent { +func (e *ExecMultiplexer) SynthEvents() <-chan *SynthEvent { return e.synthEvents } // Done returns a channel that is closed when all output has been received -func (e ExecMultiplexer) Done() <-chan struct{} { +func (e *ExecMultiplexer) Done() <-chan struct{} { return e.done } // Wait blocks until the multiplexer is done and has returned all data -func (e ExecMultiplexer) Wait() { +func (e *ExecMultiplexer) Wait() { <-e.done } diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go index 41ae6d44d600..eef25fb26860 100644 --- a/x-pack/heartbeat/scenarios/es_integration_test.go +++ b/x-pack/heartbeat/scenarios/es_integration_test.go @@ -1,20 +1,9 @@ package scenarios import ( - "fmt" - "github.com/elastic/go-elasticsearch/v8" - "github.com/stretchr/testify/require" "testing" ) -func TestStates(t *testing.T) { - esc, err := elasticsearch.NewClient(elasticsearch.Config{ - Addresses: []string{"127.0.0.1:9200"}, - Username: "elastic", - Password: "changeme", - }) - require.NoError(t, err) - h, err := esc.Cluster.Health() - require.NoError(t, err) - fmt.Printf("BODY %v", h.Body) +func TestStart(t *testing.T) { + } From 4e4af45051f31e813141acebcef9c6a8733b7c9f Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 17:32:22 -0500 Subject: [PATCH 036/102] checkpoint --- .../monitorstate/esloader_integration_test.go | 40 ++++++++++++++----- .../wrappers/monitorstate/util_test.go | 12 ++++++ 2 files changed, 43 insertions(+), 9 deletions(-) create mode 100644 heartbeat/monitors/wrappers/monitorstate/util_test.go diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 02a8d6fd726e..811e77566962 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -15,15 +15,28 @@ import ( ) func TestStates(t *testing.T) { - tc := newESTestContext(t) - - m1idUUID, _ := uuid.NewV4() - m1ID := m1idUUID.String() - m1Typ := "testtyp" - initState := newMonitorState(m1ID, StatusUp) - tc.setInitialState(t, m1Typ, initState) - ms := tc.tracker.RecordStatus(m1ID, StatusUp) - require.Equal(t, 2, ms.Checks) + etc := newESTestContext(t) + + // Create three monitors in ES, load their states, and make sure we track them correctly + // We create 3 to make sure the query isolates the monitors correctly + for i := 0; i < 3; i++ { + monID := etc.createTestMonitorStateInES(t, StatusUp) + // Since we've continued this state it should register the initial state + ms := etc.tracker.getCurrentState(monID) + requireMSCounts(t, ms, 1, 0) + + _ = etc.tracker.RecordStatus(monID, StatusUp) + ms = etc.tracker.RecordStatus(monID, StatusUp) + requireMSCounts(t, ms, 3, 0) + } + + // Let's test a final one with a down state for completeness + monID := etc.createTestMonitorStateInES(t, StatusDown) + _ = etc.tracker.RecordStatus(monID, StatusDown) + _ = etc.tracker.RecordStatus(monID, StatusDown) + _ = etc.tracker.RecordStatus(monID, StatusDown) + ms := etc.tracker.RecordStatus(monID, StatusDown) + requireMSCounts(t, ms, 0, 3) } type esTestContext struct { @@ -47,6 +60,15 @@ func newESTestContext(t *testing.T) *esTestContext { return etc } +func (etc *esTestContext) createTestMonitorStateInES(t *testing.T, s StateStatus) (id string) { + mUUID, _ := uuid.NewV4() + mID := mUUID.String() + mType := "testtyp" + initState := newMonitorState(mID, s) + etc.setInitialState(t, mType, initState) + return mID +} + func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *MonitorState) { idx := fmt.Sprintf("synthetics-%s-%s", typ, etc.namespace) diff --git a/heartbeat/monitors/wrappers/monitorstate/util_test.go b/heartbeat/monitors/wrappers/monitorstate/util_test.go new file mode 100644 index 000000000000..e3ef8b2a5c4f --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/util_test.go @@ -0,0 +1,12 @@ +package monitorstate + +import ( + "github.com/stretchr/testify/require" + "testing" +) + +func requireMSCounts(t *testing.T, ms *MonitorState, up int, down int) { + require.Equal(t, up+down, ms.Checks) + require.Equal(t, up, ms.Up) + require.Equal(t, down, ms.Down) +} From ec133a5b4174a81ab4480187b8250c518fb7aebb Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:08:12 -0500 Subject: [PATCH 037/102] Cleanup and refactor --- dev-tools/mage/integtest_docker.go | 3 - heartbeat/beater/heartbeat.go | 26 ++++--- heartbeat/monitors/active/http/http_test.go | 25 +++---- heartbeat/monitors/active/icmp/icmp_test.go | 7 +- heartbeat/monitors/active/tcp/helpers_test.go | 7 +- heartbeat/monitors/active/tcp/tls_test.go | 12 ++-- heartbeat/monitors/factory.go | 6 +- heartbeat/monitors/factory_test.go | 2 +- heartbeat/monitors/mocks.go | 16 +++-- heartbeat/monitors/monitor.go | 9 ++- heartbeat/monitors/monitor_test.go | 7 +- heartbeat/monitors/plugin/plugin.go | 5 +- .../wrappers/monitorstate/esloader.go | 9 ++- .../monitorstate/esloader_integration_test.go | 68 +++++++++++++------ .../wrappers/monitorstate/monitorstate.go | 66 +++++++++--------- .../monitorstate/monitorstate_test.go | 4 +- .../monitors/wrappers/monitorstate/tracker.go | 53 +++++++-------- .../wrappers/monitorstate/util_test.go | 12 +++- heartbeat/monitors/wrappers/wrappers.go | 10 +-- heartbeat/monitors/wrappers/wrappers_test.go | 17 ++--- x-pack/heartbeat/scenarios/framework.go | 3 +- 21 files changed, 210 insertions(+), 157 deletions(-) diff --git a/dev-tools/mage/integtest_docker.go b/dev-tools/mage/integtest_docker.go index 74e35070d30b..ad595e608a30 100644 --- a/dev-tools/mage/integtest_docker.go +++ b/dev-tools/mage/integtest_docker.go @@ -230,11 +230,9 @@ func GoIntegTestFromHost(ctx context.Context, params GoTestArgs) error { return fmt.Errorf("starting containers: %w", err) } - fmt.Println("RUN THE THING") // Run Go test from the host machine. Do not immediately exit on error to allow cleanup to occur. params.ExtraFlags = append(params.ExtraFlags, "-v") testErr := GoTest(ctx, params) - fmt.Println("RUNDONE") err = saveDockerComposeLogs(cwd, "goIntegTest") if err != nil { @@ -242,7 +240,6 @@ func GoIntegTestFromHost(ctx context.Context, params GoTestArgs) error { fmt.Printf("Failed to save docker-compose logs: %s\n", err) } - fmt.Println("STOPITALL") err = StopIntegTestContainers() if err != nil && testErr == nil { // Stopping containers failed but the test didn't diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index fd2e403e03d3..1513f4d9488c 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -49,7 +49,7 @@ type Heartbeat struct { config config.Config scheduler *scheduler.Scheduler monitorReloader *cfgfile.Reloader - dynamicFactory *monitors.RunnerFactory + monitorFactory *monitors.RunnerFactory autodiscover *autodiscover.Autodiscover } @@ -65,7 +65,12 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { if err != nil { return nil, err } - monitorstate.SetEsClient(esc) + var stateLoader monitorstate.StateLoader + if esc != nil { + stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*") + } else { + stateLoader = monitorstate.NilStateLoader + } parsedConfig := config.DefaultConfig if err := rawConfig.Unpack(&parsedConfig); err != nil { @@ -101,8 +106,9 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { done: make(chan struct{}), config: parsedConfig, scheduler: sched, - // dynamicFactory is the factory used for dynamic configs, e.g. autodiscover / reload - dynamicFactory: monitors.NewFactory(b.Info, sched.Add, plugin.GlobalPluginsReg, pipelineClientFactory), + // monitorFactory is the factory used for creating all monitor instances, + // wiring them up to everything needed to actually execute. + monitorFactory: monitors.NewFactory(b.Info, sched.Add, stateLoader, plugin.GlobalPluginsReg, pipelineClientFactory), } return bt, nil } @@ -170,7 +176,7 @@ func (bt *Heartbeat) Run(b *beat.Beat) error { func (bt *Heartbeat) RunStaticMonitors(b *beat.Beat) (stop func(), err error) { runners := make([]cfgfile.Runner, 0, len(bt.config.Monitors)) for _, cfg := range bt.config.Monitors { - created, err := bt.dynamicFactory.Create(b.Publisher, cfg) + created, err := bt.monitorFactory.Create(b.Publisher, cfg) if err != nil { if errors.Is(err, monitors.ErrMonitorDisabled) { logp.L().Info("skipping disabled monitor: %s", err) @@ -194,21 +200,21 @@ func (bt *Heartbeat) RunStaticMonitors(b *beat.Beat) (stop func(), err error) { // RunCentralMgmtMonitors loads any central management configured configs. func (bt *Heartbeat) RunCentralMgmtMonitors(b *beat.Beat) { - mons := cfgfile.NewRunnerList(management.DebugK, bt.dynamicFactory, b.Publisher) + mons := cfgfile.NewRunnerList(management.DebugK, bt.monitorFactory, b.Publisher) reload.Register.MustRegisterList(b.Info.Beat+".monitors", mons) - inputs := cfgfile.NewRunnerList(management.DebugK, bt.dynamicFactory, b.Publisher) + inputs := cfgfile.NewRunnerList(management.DebugK, bt.monitorFactory, b.Publisher) reload.Register.MustRegisterList("inputs", inputs) } // RunReloadableMonitors runs the `heartbeat.config.monitors` portion of the yaml config if present. func (bt *Heartbeat) RunReloadableMonitors() (err error) { // Check monitor configs - if err := bt.monitorReloader.Check(bt.dynamicFactory); err != nil { + if err := bt.monitorReloader.Check(bt.monitorFactory); err != nil { logp.Error(fmt.Errorf("error loading reloadable monitors: %w", err)) } // Execute the monitor - go bt.monitorReloader.Run(bt.dynamicFactory) + go bt.monitorReloader.Run(bt.monitorFactory) return nil } @@ -218,7 +224,7 @@ func (bt *Heartbeat) makeAutodiscover(b *beat.Beat) (*autodiscover.Autodiscover, ad, err := autodiscover.NewAutodiscover( "heartbeat", b.Publisher, - bt.dynamicFactory, + bt.monitorFactory, autodiscover.QueryConfig(), bt.config.Autodiscover, b.Keystore, diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 0054268e919f..9f1f3aaef53a 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -41,6 +41,13 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + conf "github.com/elastic/elastic-agent-libs/config" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/isdef" + "github.com/elastic/go-lookslike/testslike" + "github.com/elastic/go-lookslike/validator" + "github.com/elastic/beats/v7/heartbeat/hbtest" "github.com/elastic/beats/v7/heartbeat/hbtestllext" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" @@ -49,12 +56,6 @@ import ( "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common/file" btesting "github.com/elastic/beats/v7/libbeat/testing" - conf "github.com/elastic/elastic-agent-libs/config" - "github.com/elastic/elastic-agent-libs/mapstr" - "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/isdef" - "github.com/elastic/go-lookslike/testslike" - "github.com/elastic/go-lookslike/validator" ) func sendSimpleTLSRequest(t *testing.T, testURL string, useUrls bool) *beat.Event { @@ -85,7 +86,7 @@ func sendTLSRequest(t *testing.T, testURL string, useUrls bool, extraConfig map[ require.NoError(t, err) sched := schedule.MustParse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "tls", Type: "http", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "tls", Type: "http", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) @@ -325,7 +326,7 @@ func TestLargeResponse(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) @@ -441,7 +442,7 @@ func TestJsonBody(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) @@ -676,7 +677,7 @@ func TestRedirect(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1}, nil)[0] // Run this test multiple times since in the past we had an issue where the redirects // list was added onto by each request. See https://github.com/elastic/beats/pull/15944 @@ -723,7 +724,7 @@ func TestNoHeaders(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) @@ -907,7 +908,7 @@ func TestUserAgentInject(t *testing.T) { require.NoError(t, err) sched, _ := schedule.Parse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "http", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/active/icmp/icmp_test.go b/heartbeat/monitors/active/icmp/icmp_test.go index e7dbba751b92..f4597d0a4db8 100644 --- a/heartbeat/monitors/active/icmp/icmp_test.go +++ b/heartbeat/monitors/active/icmp/icmp_test.go @@ -25,6 +25,9 @@ import ( "github.com/stretchr/testify/require" + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/testslike" + "github.com/elastic/beats/v7/heartbeat/hbtest" "github.com/elastic/beats/v7/heartbeat/look" "github.com/elastic/beats/v7/heartbeat/monitors" @@ -32,8 +35,6 @@ import ( "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" "github.com/elastic/beats/v7/heartbeat/scheduler/schedule" "github.com/elastic/beats/v7/libbeat/beat" - "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/testslike" ) func TestICMPFields(t *testing.T) { @@ -71,7 +72,7 @@ func execTestICMPCheck(t *testing.T, cfg Config) (mockLoop, *beat.Event) { require.Equal(t, 1, p.Endpoints) e := &beat.Event{} sched, _ := schedule.Parse("@every 1s") - wrapped := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "icmp", Schedule: sched, Timeout: 1}) + wrapped := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "icmp", Schedule: sched, Timeout: 1}, nil) _, _ = wrapped[0](e) return tl, e } diff --git a/heartbeat/monitors/active/tcp/helpers_test.go b/heartbeat/monitors/active/tcp/helpers_test.go index 9d1a89e21017..781c5ad28e97 100644 --- a/heartbeat/monitors/active/tcp/helpers_test.go +++ b/heartbeat/monitors/active/tcp/helpers_test.go @@ -26,13 +26,14 @@ import ( "github.com/stretchr/testify/require" + conf "github.com/elastic/elastic-agent-libs/config" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/hbtest" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" "github.com/elastic/beats/v7/heartbeat/scheduler/schedule" "github.com/elastic/beats/v7/libbeat/beat" - conf "github.com/elastic/elastic-agent-libs/config" - "github.com/elastic/elastic-agent-libs/mapstr" ) func testTCPConfigCheck(t *testing.T, configMap mapstr.M) *beat.Event { @@ -43,7 +44,7 @@ func testTCPConfigCheck(t *testing.T, configMap mapstr.M) *beat.Event { require.NoError(t, err) sched := schedule.MustParse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "tcp", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "tcp", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/active/tcp/tls_test.go b/heartbeat/monitors/active/tcp/tls_test.go index 088c46641d65..cbf714a96853 100644 --- a/heartbeat/monitors/active/tcp/tls_test.go +++ b/heartbeat/monitors/active/tcp/tls_test.go @@ -30,19 +30,21 @@ import ( "strconv" "testing" + conf "github.com/elastic/elastic-agent-libs/config" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" "github.com/elastic/beats/v7/heartbeat/scheduler/schedule" "github.com/elastic/beats/v7/libbeat/beat" - conf "github.com/elastic/elastic-agent-libs/config" - "github.com/elastic/elastic-agent-libs/mapstr" "github.com/stretchr/testify/require" - "github.com/elastic/beats/v7/heartbeat/hbtest" - "github.com/elastic/beats/v7/heartbeat/monitors" "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/testslike" + + "github.com/elastic/beats/v7/heartbeat/hbtest" + "github.com/elastic/beats/v7/heartbeat/monitors" ) // Tests that we can check a TLS connection with a cert for a SAN IP @@ -194,7 +196,7 @@ func testTLSTCPCheck(t *testing.T, host string, port uint16, certFileName string require.NoError(t, err) sched := schedule.MustParse("@every 1s") - job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "tcp", Schedule: sched, Timeout: 1})[0] + job := wrappers.WrapCommon(p.Jobs, stdfields.StdMonitorFields{ID: "test", Type: "tcp", Schedule: sched, Timeout: 1}, nil)[0] event := &beat.Event{} _, err = job(event) diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index 25b626843589..9c9e1af5bb5b 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -27,6 +27,7 @@ import ( "github.com/elastic/beats/v7/heartbeat/monitors/plugin" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/elastic/beats/v7/heartbeat/scheduler" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/cfgfile" @@ -44,6 +45,7 @@ import ( type RunnerFactory struct { info beat.Info addTask scheduler.AddTask + stateLoader monitorstate.StateLoader byId map[string]*Monitor mtx *sync.Mutex pluginsReg *plugin.PluginsReg @@ -73,7 +75,7 @@ type publishSettings struct { } // NewFactory takes a scheduler and creates a RunnerFactory that can create cfgfile.Runner(Monitor) objects. -func NewFactory(info beat.Info, addTask scheduler.AddTask, pluginsReg *plugin.PluginsReg, pcf PipelineClientFactory) *RunnerFactory { +func NewFactory(info beat.Info, addTask scheduler.AddTask, stateLoader monitorstate.StateLoader, pluginsReg *plugin.PluginsReg, pcf PipelineClientFactory) *RunnerFactory { return &RunnerFactory{ info: info, addTask: addTask, @@ -143,7 +145,7 @@ func (f *RunnerFactory) Create(p beat.Pipeline, c *conf.C) (cfgfile.Runner, erro if err != nil { return nil, fmt.Errorf("could not create pipeline client via factory: %w", err) } - monitor, err := newMonitor(c, f.pluginsReg, pc, f.addTask, safeStop) + monitor, err := newMonitor(c, f.pluginsReg, pc, f.addTask, f.stateLoader, safeStop) if err != nil { return nil, fmt.Errorf("factory could not create monitor: %w", err) } diff --git a/heartbeat/monitors/factory_test.go b/heartbeat/monitors/factory_test.go index 8ba16f52377c..8772b2b71792 100644 --- a/heartbeat/monitors/factory_test.go +++ b/heartbeat/monitors/factory_test.go @@ -200,7 +200,7 @@ func TestDuplicateMonitorIDs(t *testing.T) { } // Ensure that an error is returned on a bad config - _, m0Err := newMonitor(badConf, reg, mockPipeline.ConnectSync(), sched.Add, nil) + _, m0Err := newMonitor(badConf, reg, mockPipeline.ConnectSync(), sched.Add, nil, nil) require.Error(t, m0Err) // Would fail if the previous newMonitor didn't free the monitor.id diff --git a/heartbeat/monitors/mocks.go b/heartbeat/monitors/mocks.go index 5063824f1343..1d513cfada5f 100644 --- a/heartbeat/monitors/mocks.go +++ b/heartbeat/monitors/mocks.go @@ -27,22 +27,24 @@ import ( "github.com/gofrs/uuid" "github.com/stretchr/testify/require" + "github.com/elastic/elastic-agent-libs/config" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/elastic-agent-libs/monitoring" + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/isdef" + "github.com/elastic/go-lookslike/validator" + "github.com/elastic/beats/v7/heartbeat/eventext" "github.com/elastic/beats/v7/heartbeat/hbtest" "github.com/elastic/beats/v7/heartbeat/hbtestllext" "github.com/elastic/beats/v7/heartbeat/monitors/jobs" "github.com/elastic/beats/v7/heartbeat/monitors/plugin" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/elastic/beats/v7/heartbeat/scheduler" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common/atomic" "github.com/elastic/beats/v7/libbeat/publisher/pipeline" beatversion "github.com/elastic/beats/v7/libbeat/version" - "github.com/elastic/elastic-agent-libs/config" - "github.com/elastic/elastic-agent-libs/mapstr" - "github.com/elastic/elastic-agent-libs/monitoring" - "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/isdef" - "github.com/elastic/go-lookslike/validator" ) func makeMockFactory(pluginsReg *plugin.PluginsReg) (factory *RunnerFactory, sched *scheduler.Scheduler, close func()) { @@ -74,7 +76,7 @@ func makeMockFactory(pluginsReg *plugin.PluginsReg) (factory *RunnerFactory, sch true, ) - return NewFactory(info, sched.Add, pluginsReg, func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { + return NewFactory(info, sched.Add, monitorstate.NilStateLoader, pluginsReg, func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { c, _ := pipeline.Connect() return SyncPipelineClientAdaptor{C: c}, nil }), diff --git a/heartbeat/monitors/monitor.go b/heartbeat/monitors/monitor.go index 8d500629ecee..fb759f074d69 100644 --- a/heartbeat/monitors/monitor.go +++ b/heartbeat/monitors/monitor.go @@ -21,6 +21,7 @@ import ( "fmt" "sync" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/elastic/beats/v7/libbeat/publisher/pipeline" "github.com/mitchellh/hashstructure" @@ -78,7 +79,7 @@ func (m *Monitor) String() string { } func checkMonitorConfig(config *conf.C, registrar *plugin.PluginsReg) error { - _, err := newMonitor(config, registrar, nil, nil, nil) + _, err := newMonitor(config, registrar, nil, nil, monitorstate.NilStateLoader, nil) return err } @@ -90,9 +91,10 @@ func newMonitor( registrar *plugin.PluginsReg, pubClient pipeline.ISyncClient, taskAdder scheduler.AddTask, + stateLoader monitorstate.StateLoader, onStop func(*Monitor), ) (*Monitor, error) { - m, err := newMonitorUnsafe(config, registrar, pubClient, taskAdder, onStop) + m, err := newMonitorUnsafe(config, registrar, pubClient, taskAdder, stateLoader, onStop) if m != nil && err != nil { m.Stop() } @@ -106,6 +108,7 @@ func newMonitorUnsafe( registrar *plugin.PluginsReg, pubClient pipeline.ISyncClient, addTask scheduler.AddTask, + stateLoader monitorstate.StateLoader, onStop func(*Monitor), ) (*Monitor, error) { // Extract just the Id, Type, and Enabled fields from the config @@ -170,7 +173,7 @@ func newMonitorUnsafe( }} } - wrappedJobs := wrappers.WrapCommon(p.Jobs, m.stdFields) + wrappedJobs := wrappers.WrapCommon(p.Jobs, m.stdFields, stateLoader) m.endpoints = p.Endpoints m.configuredJobs, err = m.makeTasks(config, wrappedJobs) diff --git a/heartbeat/monitors/monitor_test.go b/heartbeat/monitors/monitor_test.go index 9585920cc53e..560e46fcdea1 100644 --- a/heartbeat/monitors/monitor_test.go +++ b/heartbeat/monitors/monitor_test.go @@ -24,7 +24,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "github.com/elastic/beats/v7/heartbeat/scheduler" conf "github.com/elastic/elastic-agent-libs/config" "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/elastic-agent-libs/monitoring" @@ -32,6 +31,8 @@ import ( "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" + + "github.com/elastic/beats/v7/heartbeat/scheduler" ) // TestMonitorBasic tests a basic config @@ -68,7 +69,7 @@ func testMonitorConfig(t *testing.T, conf *conf.C, eventValidator validator.Vali sched := scheduler.Create(1, monitoring.NewRegistry(), time.Local, nil, false) defer sched.Stop() - mon, err := newMonitor(conf, reg, pipel.ConnectSync(), sched.Add, nil) + mon, err := newMonitor(conf, reg, pipel.ConnectSync(), sched.Add, nil, nil) require.NoError(t, err) mon.Start() @@ -115,7 +116,7 @@ func TestCheckInvalidConfig(t *testing.T) { sched := scheduler.Create(1, monitoring.NewRegistry(), time.Local, nil, false) defer sched.Stop() - m, err := newMonitor(serverMonConf, reg, pipel.ConnectSync(), sched.Add, nil) + m, err := newMonitor(serverMonConf, reg, pipel.ConnectSync(), sched.Add, nil, nil) require.Error(t, err) // This could change if we decide the contract for newMonitor should always return a monitor require.Nil(t, m, "For this test to work we need a nil value for the monitor.") diff --git a/heartbeat/monitors/plugin/plugin.go b/heartbeat/monitors/plugin/plugin.go index e156cb144f42..e8b4ab9f4a3a 100644 --- a/heartbeat/monitors/plugin/plugin.go +++ b/heartbeat/monitors/plugin/plugin.go @@ -23,13 +23,14 @@ import ( "sort" "strings" + conf "github.com/elastic/elastic-agent-libs/config" + "github.com/elastic/beats/v7/heartbeat/hbregistry" "github.com/elastic/beats/v7/heartbeat/monitors/jobs" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/plugin" - conf "github.com/elastic/elastic-agent-libs/config" ) // PluginFactory represents an uninstantiated plug in instance generated from a monitor config. Invoking the Make function creates a plug-in instance. @@ -59,7 +60,7 @@ func (p Plugin) Close() error { // RunWrapped runs the plug-in with the provided wrappers returning a channel of resultant events. func (p Plugin) RunWrapped(fields stdfields.StdMonitorFields) chan *beat.Event { - wj := wrappers.WrapCommon(p.Jobs, fields) + wj := wrappers.WrapCommon(p.Jobs, fields, nil) results := make(chan *beat.Event) var runJob func(j jobs.Job) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader.go b/heartbeat/monitors/wrappers/monitorstate/esloader.go index 470a62f6ac98..76eb35ee12bc 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "github.com/elastic/elastic-agent-libs/logp" "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/go-elasticsearch/v8" @@ -14,9 +15,11 @@ import ( func MakeESLoader(esc *elasticsearch.Client, indexPattern string) StateLoader { if indexPattern == "" { - indexPattern = "synthetics-*" + // Should never happen, but if we ever make a coding error... + logp.L().Warn("ES state loader initialized with no index pattern, will not load states from ES") + return NilStateLoader } - return func(monitorId string) (*MonitorState, error) { + return func(monitorId string) (*State, error) { reqBody, err := json.Marshal(mapstr.M{ "sort": mapstr.M{"@timestamp": "desc"}, "query": mapstr.M{ @@ -53,7 +56,7 @@ func MakeESLoader(esc *elasticsearch.Client, indexPattern string) StateLoader { Hits []struct { DocId string `json:"string"` Source struct { - State MonitorState `json:"state"` + State State `json:"state"` } `json:"_source"` } `json:"hits"` } `json:"hits"` diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 811e77566962..a1b8ac6828f4 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -18,32 +18,58 @@ func TestStates(t *testing.T) { etc := newESTestContext(t) // Create three monitors in ES, load their states, and make sure we track them correctly - // We create 3 to make sure the query isolates the monitors correctly - for i := 0; i < 3; i++ { - monID := etc.createTestMonitorStateInES(t, StatusUp) + // We create a few to make sure the query isolates the monitors correctly + // and alternate between testing monitors that start up or down + for i := 0; i < 10; i++ { + testStatus := StatusUp + if i%2 == 1 { + testStatus = StatusDown + } + + monID := etc.createTestMonitorStateInES(t, testStatus) // Since we've continued this state it should register the initial state ms := etc.tracker.getCurrentState(monID) - requireMSCounts(t, ms, 1, 0) - - _ = etc.tracker.RecordStatus(monID, StatusUp) - ms = etc.tracker.RecordStatus(monID, StatusUp) - requireMSCounts(t, ms, 3, 0) + requireMSStatusCount(t, ms, testStatus, 1) + + // Write the state a few times, enough to guarantee a stable state + count := FlappingThreshold * 2 + var lastId string + for i := 0; i < count; i++ { + ms = etc.tracker.RecordStatus(monID, testStatus) + if i == 0 { + lastId = ms.Id + } + require.Equal(t, lastId, ms.Id, "state ID should not change within state") + } + // The initial state adds 1 to count + requireMSStatusCount(t, ms, testStatus, count+1) + + // now change the state + if testStatus == StatusUp { + testStatus = StatusDown + } else { + testStatus = StatusUp + } + + origMsId := ms.Id + for i := 0; i < count; i++ { + ms = etc.tracker.RecordStatus(monID, testStatus) + require.NotEqual(t, origMsId, ms.Id) + if i == 0 { + lastId = ms.Id + require.Equal(t, origMsId, ms.Ends.Id, "transition should point to the prior state") + } + require.Equal(t, lastId, ms.Id, "state ID should not change within state") + } + requireMSStatusCount(t, ms, testStatus, count) } - - // Let's test a final one with a down state for completeness - monID := etc.createTestMonitorStateInES(t, StatusDown) - _ = etc.tracker.RecordStatus(monID, StatusDown) - _ = etc.tracker.RecordStatus(monID, StatusDown) - _ = etc.tracker.RecordStatus(monID, StatusDown) - ms := etc.tracker.RecordStatus(monID, StatusDown) - requireMSCounts(t, ms, 0, 3) } type esTestContext struct { namespace string esc *elasticsearch.Client loader StateLoader - tracker *MonitorStateTracker + tracker *Tracker } func newESTestContext(t *testing.T) *esTestContext { @@ -69,7 +95,7 @@ func (etc *esTestContext) createTestMonitorStateInES(t *testing.T, s StateStatus return mID } -func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *MonitorState) { +func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *State) { idx := fmt.Sprintf("synthetics-%s-%s", typ, etc.namespace) type Mon struct { @@ -78,9 +104,9 @@ func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *MonitorS } reqBodyRdr, err := esutil.ToJsonRdr(struct { - Ts time.Time `json:"@timestamp"` - Monitor Mon `json:"monitor"` - State *MonitorState `json:"state"` + Ts time.Time `json:"@timestamp"` + Monitor Mon `json:"monitor"` + State *State `json:"state"` }{ Ts: time.Now(), Monitor: Mon{Id: ms.MonitorId, Type: typ}, diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index dc19376f535c..a84dad035508 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -15,9 +15,9 @@ const ( StatusFlapping StateStatus = "flap" ) -func newMonitorState(monitorId string, status StateStatus) *MonitorState { +func newMonitorState(monitorId string, status StateStatus) *State { nowMillis := time.Now().UnixMilli() - ms := &MonitorState{ + ms := &State{ Id: fmt.Sprintf("%s-%x", monitorId, nowMillis), MonitorId: monitorId, StartedAtMs: float64(nowMillis), @@ -33,7 +33,7 @@ type HistoricalStatus struct { Status StateStatus `json:"status"` } -type MonitorState struct { +type State struct { MonitorId string `json:"monitorId"` Id string `json:"id"` StartedAtMs float64 `json:"started_at_ms"` @@ -42,21 +42,21 @@ type MonitorState struct { Up int `json:"up"` Down int `json:"down"` FlapHistory []StateStatus `json:"flap_history"` - Ends *MonitorState `json:"ends"` + Ends *State `json:"ends"` } -func (ms *MonitorState) incrementCounters(status StateStatus) { - ms.Checks++ +func (s *State) incrementCounters(status StateStatus) { + s.Checks++ if status == StatusUp { - ms.Up++ + s.Up++ } else { - ms.Down++ + s.Down++ } } // truncate flap history to be at most as many items as the threshold indicates, minus one -func (ms *MonitorState) truncateFlapHistory() { - endIdx := len(ms.FlapHistory) +func (s *State) truncateFlapHistory() { + endIdx := len(s.FlapHistory) if endIdx < 0 { return // flap history is empty } @@ -66,20 +66,20 @@ func (ms *MonitorState) truncateFlapHistory() { if startIdx <= 0 { return } - ms.FlapHistory = ms.FlapHistory[startIdx:endIdx] + s.FlapHistory = s.FlapHistory[startIdx:endIdx] } // recordCheck updates the current state pointer to what the new state should be. // If the current state is continued it just updates counters and other record keeping, // if the state ends it actually swaps out the full value the state points to // and sets state.Ends. -func (ms *MonitorState) recordCheck(newStatus StateStatus) { - if ms.Status == StatusFlapping { - ms.truncateFlapHistory() +func (s *State) recordCheck(newStatus StateStatus) { + if s.Status == StatusFlapping { + s.truncateFlapHistory() // Check if all statuses in flap history are identical, including the new status hasStabilized := true - for _, histStatus := range ms.FlapHistory { + for _, histStatus := range s.FlapHistory { if newStatus != histStatus { hasStabilized = false break @@ -88,34 +88,34 @@ func (ms *MonitorState) recordCheck(newStatus StateStatus) { if !hasStabilized { // continue flapping // Use the new flap history as part of the state - ms.FlapHistory = append(ms.FlapHistory, newStatus) - ms.incrementCounters(newStatus) + s.FlapHistory = append(s.FlapHistory, newStatus) + s.incrementCounters(newStatus) } else { // flap has ended - oldState := *ms - *ms = *newMonitorState(ms.MonitorId, newStatus) - ms.Ends = &oldState + oldState := *s + *s = *newMonitorState(s.MonitorId, newStatus) + s.Ends = &oldState } - } else if ms.Status == newStatus { // stable state, status has not changed + } else if s.Status == newStatus { // stable state, status has not changed // The state is stable, no changes needed - ms.incrementCounters(newStatus) - } else if ms.Checks < FlappingThreshold { + s.incrementCounters(newStatus) + } else if s.Checks < FlappingThreshold { // The state changed too quickly, we're now flapping - ms.incrementCounters(newStatus) - ms.Status = StatusFlapping - ms.FlapHistory = append(ms.FlapHistory, newStatus) + s.incrementCounters(newStatus) + s.Status = StatusFlapping + s.FlapHistory = append(s.FlapHistory, newStatus) } else { // state has changed, but we aren't flapping (yet), since we've been stable past the // flapping threshold - oldState := *ms - *ms = *newMonitorState(ms.MonitorId, newStatus) - ms.Ends = &oldState + oldState := *s + *s = *newMonitorState(s.MonitorId, newStatus) + s.Ends = &oldState } } // copy returns a threadsafe copy since the instance used in the tracker is frequently mutated -func (ms *MonitorState) copy() *MonitorState { - copied := *ms - copied.FlapHistory = make([]StateStatus, len(ms.FlapHistory)) - copy(copied.FlapHistory, ms.FlapHistory) +func (s *State) copy() *State { + copied := *s + copied.FlapHistory = make([]StateStatus, len(s.FlapHistory)) + copy(copied.FlapHistory, s.FlapHistory) return &copied } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index 15dfd657b0c7..d0803313413b 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -33,7 +33,7 @@ func TestRecordingAndFlapping(t *testing.T) { } // recordFlappingSeries is a helper that should always put the monitor into a flapping state. -func recordFlappingSeries(ms *MonitorState) { +func recordFlappingSeries(ms *State) { for i := 0; i < FlappingThreshold; i++ { if i%2 == 0 { ms.recordCheck(StatusUp) @@ -44,7 +44,7 @@ func recordFlappingSeries(ms *MonitorState) { } // recordStableSeries is a test helper for repeatedly recording one status -func recordStableSeries(ms *MonitorState, count int, s StateStatus) { +func recordStableSeries(ms *State, count int, s StateStatus) { for i := 0; i < count; i++ { ms.recordCheck(s) } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index a96d4f5c8158..373e3eb592aa 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -6,55 +6,46 @@ import ( "time" "github.com/elastic/elastic-agent-libs/logp" - "github.com/elastic/go-elasticsearch/v8" ) -var esClient *elasticsearch.Client - -func SetEsClient(c *elasticsearch.Client) { - esClient = c -} - // NewMonitorStateTracker tracks state across job runs. It takes an optional // state loader, which will try to fetch the last known state for a never // before seen monitor, which usually means using ES. If set to nil // it will use ES if configured, otherwise it will only track state from // memory. -func NewMonitorStateTracker(sl StateLoader) *MonitorStateTracker { - mst := &MonitorStateTracker{ - states: map[string]*MonitorState{}, +func NewMonitorStateTracker(sl StateLoader) *Tracker { + t := &Tracker{ + states: map[string]*State{}, mtx: sync.Mutex{}, stateLoader: sl, } - if esClient != nil { - mst.stateLoader = MakeESLoader(esClient, "") - } - if mst.stateLoader == nil { - mst.stateLoader = NilStateLoader + if t.stateLoader == nil { + t.stateLoader = NilStateLoader } - return mst + + return t } -type MonitorStateTracker struct { - states map[string]*MonitorState +type Tracker struct { + states map[string]*State mtx sync.Mutex stateLoader StateLoader } // StateLoader has signature as loadLastESState, useful for test mocking, and maybe for a future impl // other than ES if necessary -type StateLoader func(monitorId string) (*MonitorState, error) +type StateLoader func(monitorId string) (*State, error) -func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus StateStatus) (ms *MonitorState) { +func (t *Tracker) RecordStatus(monitorId string, newStatus StateStatus) (ms *State) { //note: the return values have no concurrency controls, they may be unsafely read unless //copied to the stack, copying the structs before returning - mst.mtx.Lock() - defer mst.mtx.Unlock() + t.mtx.Lock() + defer t.mtx.Unlock() - state := mst.getCurrentState(monitorId) + state := t.getCurrentState(monitorId) if state == nil { state = newMonitorState(monitorId, newStatus) - mst.states[monitorId] = state + t.states[monitorId] = state } else { state.recordCheck(newStatus) } @@ -62,16 +53,16 @@ func (mst *MonitorStateTracker) RecordStatus(monitorId string, newStatus StateSt return state.copy() } -func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *MonitorState) { - if state, ok := mst.states[monitorId]; ok { +func (t *Tracker) getCurrentState(monitorId string) (state *State) { + if state, ok := t.states[monitorId]; ok { return state } tries := 3 - var loadedState *MonitorState + var loadedState *State var err error for i := 0; i < tries; i++ { - loadedState, err = mst.stateLoader(monitorId) + loadedState, err = t.stateLoader(monitorId) if err != nil { sleepFor := (time.Duration(i*i) * time.Second) + (time.Duration(rand.Intn(500)) * time.Millisecond) logp.L().Warnf("could not load last externally recorded state, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) @@ -82,12 +73,16 @@ func (mst *MonitorStateTracker) getCurrentState(monitorId string) (state *Monito logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorId) } + if loadedState != nil { + t.states[monitorId] = loadedState + } + // Return what we found, even if nil return loadedState } // NilStateLoader always returns nil, nil. It's the default when no ES conn is available // or during testing -func NilStateLoader(_ string) (*MonitorState, error) { +func NilStateLoader(_ string) (*State, error) { return nil, nil } diff --git a/heartbeat/monitors/wrappers/monitorstate/util_test.go b/heartbeat/monitors/wrappers/monitorstate/util_test.go index e3ef8b2a5c4f..decff7a3552f 100644 --- a/heartbeat/monitors/wrappers/monitorstate/util_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/util_test.go @@ -5,7 +5,17 @@ import ( "testing" ) -func requireMSCounts(t *testing.T, ms *MonitorState, up int, down int) { +func requireMSStatusCount(t *testing.T, ms *State, status StateStatus, count int) { + if status == StatusUp { + requireMSCounts(t, ms, count, 0) + } else if status == StatusDown { + requireMSCounts(t, ms, 0, count) + } else { + panic("can only check up or down statuses") + } +} + +func requireMSCounts(t *testing.T, ms *State, up int, down int) { require.Equal(t, up+down, ms.Checks) require.Equal(t, up, ms.Up) require.Equal(t, down, ms.Down) diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 58fbdb3ab4c0..c467b6913b1f 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -42,8 +42,8 @@ import ( ) // WrapCommon applies the common wrappers that all monitor jobs get. -func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields) []jobs.Job { - mst := monitorstate.NewMonitorStateTracker(nil) +func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, stateLoader monitorstate.StateLoader) []jobs.Job { + mst := monitorstate.NewMonitorStateTracker(stateLoader) if stdMonFields.Type == "browser" { return WrapBrowser(js, stdMonFields, mst) } else { @@ -52,7 +52,7 @@ func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields) []jobs.J } // WrapLightweight applies to http/tcp/icmp, everything but journeys involving node -func WrapLightweight(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst *monitorstate.MonitorStateTracker) []jobs.Job { +func WrapLightweight(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst *monitorstate.Tracker) []jobs.Job { return jobs.WrapAllSeparately( jobs.WrapAll( js, @@ -71,7 +71,7 @@ func WrapLightweight(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst // WrapBrowser is pretty minimal in terms of fields added. The browser monitor // type handles most of the fields directly, since it runs multiple jobs in a single // run it needs to take this task on in a unique way. -func WrapBrowser(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst *monitorstate.MonitorStateTracker) []jobs.Job { +func WrapBrowser(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst *monitorstate.Tracker) []jobs.Job { return jobs.WrapAll( js, addMonitorTimespan(stdMonFields), @@ -84,7 +84,7 @@ func WrapBrowser(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst *mo } // addMonitorState computes the various state fields -func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.MonitorStateTracker) jobs.JobWrapper { +func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.Tracker) jobs.JobWrapper { return func(job jobs.Job) jobs.Job { return func(event *beat.Event) ([]jobs.Job, error) { cont, err := job(event) diff --git a/heartbeat/monitors/wrappers/wrappers_test.go b/heartbeat/monitors/wrappers/wrappers_test.go index 23ef7474762e..0bbe5d81ed3b 100644 --- a/heartbeat/monitors/wrappers/wrappers_test.go +++ b/heartbeat/monitors/wrappers/wrappers_test.go @@ -30,6 +30,13 @@ import ( "go.uber.org/zap/zapcore" "go.uber.org/zap/zaptest/observer" + "github.com/elastic/elastic-agent-libs/logp" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/go-lookslike" + "github.com/elastic/go-lookslike/isdef" + "github.com/elastic/go-lookslike/testslike" + "github.com/elastic/go-lookslike/validator" + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/eventext" "github.com/elastic/beats/v7/heartbeat/hbtestllext" @@ -38,12 +45,6 @@ import ( "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/scheduler/schedule" "github.com/elastic/beats/v7/libbeat/beat" - "github.com/elastic/elastic-agent-libs/logp" - "github.com/elastic/elastic-agent-libs/mapstr" - "github.com/elastic/go-lookslike" - "github.com/elastic/go-lookslike/isdef" - "github.com/elastic/go-lookslike/testslike" - "github.com/elastic/go-lookslike/validator" ) type testDef struct { @@ -71,7 +72,7 @@ var testBrowserMonFields = stdfields.StdMonitorFields{ func testCommonWrap(t *testing.T, tt testDef) { t.Run(tt.name, func(t *testing.T) { - wrapped := WrapCommon(tt.jobs, tt.sFields) + wrapped := WrapCommon(tt.jobs, tt.sFields, nil) core, observedLogs := observer.New(zapcore.InfoLevel) logger.SetLogger(logp.NewLogger("t", zap.WrapCore(func(in zapcore.Core) zapcore.Core { @@ -711,7 +712,7 @@ func TestECSErrors(t *testing.T) { wrappedEcsErr.Error(), ) - j := WrapCommon([]jobs.Job{makeProjectBrowserJob(t, "http://example.net", true, wrappedEcsErr, projectMonitorValues)}, testBrowserMonFields) + j := WrapCommon([]jobs.Job{makeProjectBrowserJob(t, "http://example.net", true, wrappedEcsErr, projectMonitorValues)}, testBrowserMonFields, nil) event := &beat.Event{} _, err := j[0](event) require.NoError(t, err) diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 4438994a6844..0b0057a09a7a 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -11,6 +11,7 @@ import ( "time" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/gofrs/uuid" "github.com/stretchr/testify/require" @@ -171,7 +172,7 @@ func setupFactoryAndSched() (factory *monitors.RunnerFactory, sched *scheduler.S true, ) - return monitors.NewFactory(info, sched.Add, plugin.GlobalPluginsReg, func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { + return monitors.NewFactory(info, sched.Add, monitorstate.NilStateLoader, plugin.GlobalPluginsReg, func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { c, _ := pipeline.Connect() return monitors.SyncPipelineClientAdaptor{C: c}, nil }), From bed5fbfbaff96bf1121f9b5695c1c6152091bf36 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:10:03 -0500 Subject: [PATCH 038/102] Changelog --- CHANGELOG.next.asciidoc | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index c20709197644..a7685a17b465 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -130,6 +130,7 @@ https://github.com/elastic/beats/compare/v8.2.0\...main[Check the HEAD diff] *Heartbeat* +- Add new states field for internal use by new synthetics app. {pull}30632[30632] *Metricbeat* From d42b3831e651473109f496b703abaaa5128de921 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:11:41 -0500 Subject: [PATCH 039/102] Cleanup dev tools usage --- dev-tools/dummy_http/main.go | 192 ----------------------------- dev-tools/mage/integtest_docker.go | 1 - 2 files changed, 193 deletions(-) delete mode 100644 dev-tools/dummy_http/main.go diff --git a/dev-tools/dummy_http/main.go b/dev-tools/dummy_http/main.go deleted file mode 100644 index 296a217227d8..000000000000 --- a/dev-tools/dummy_http/main.go +++ /dev/null @@ -1,192 +0,0 @@ -package main - -import ( - "fmt" - "math/rand" - "net/http" - "net/url" - "os" - "regexp" - "strconv" - "strings" - "sync" - "sync/atomic" - "time" -) - -// An URL like /pattern?r='200x50,404x20,200|500x30' -// The above pattern would return 50 200 responses, then 20 404s, then randomly return a mix of 200 and 500 -// responses 30 times - -func main() { - states := &sync.Map{} - - var reqs uint64 = 0 - - http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) { - atomic.AddUint64(&reqs, 1) - - _, _ = writer.Write([]byte("Dummy HTTP Server")) - }) - - http.HandleFunc("/pattern", func(writer http.ResponseWriter, request *http.Request) { - atomic.AddUint64(&reqs, 1) - - status, body := handlePattern(states, request.URL) - writer.WriteHeader(status) - _, _ = writer.Write([]byte(body)) - }) - - go func() { - for { - time.Sleep(time.Second * 10) - r := atomic.LoadUint64(&reqs) - // nolint forbidigo - fmt.Printf("Processed %d reqs\n", r) - } - }() - - port := 5678 - // nolint forbidigo - fmt.Printf("Starting server on port %d\n", port) - err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil) - if err != nil { - // nolint forbidigo - fmt.Printf("Could not start server: %s", err) - os.Exit(1) - } -} - -type responsePattern struct { - httpStatuses []int - httpStatusesLen int - countLimit int -} - -func (rp *responsePattern) next() (status int, body string) { - var idx int - if rp.httpStatusesLen > 1 { - // nolint forbidigo - fmt.Printf("INTN %d\n", rp.httpStatusesLen) - idx = rand.Intn(rp.httpStatusesLen) - } else { - idx = 0 - } - status = rp.httpStatuses[idx] - return status, strconv.Itoa(status) -} - -type responsePatternSequence struct { - currentPatternIdx int - currentPattern *responsePattern - currentPatternCount int - patterns []*responsePattern - shuffle bool - mtx sync.Mutex -} - -func (ps *responsePatternSequence) next() (status int, body string) { - ps.mtx.Lock() - defer ps.mtx.Unlock() - - if ps.currentPatternCount >= ps.currentPattern.countLimit { - ps.advancePattern() - } - - ps.currentPatternCount = ps.currentPatternCount + 1 - return ps.currentPattern.next() -} - -func (ps *responsePatternSequence) advancePattern() { - if ps.shuffle { - ps.currentPatternIdx = rand.Intn(len(ps.patterns)) - 1 - ps.currentPattern = ps.patterns[ps.currentPatternIdx] - } else { - var nextIdx = ps.currentPatternIdx + 1 - if nextIdx == len(ps.patterns) { - nextIdx = 0 - } - ps.currentPatternIdx = nextIdx - ps.currentPattern = ps.patterns[nextIdx] - } - - ps.currentPatternCount = 0 -} - -var statusListRegexp = regexp.MustCompile(`^[|\\d]+$`) - -func handlePattern(states *sync.Map, url *url.URL) (status int, body string) { - query := url.Query() - - rpsInter, ok := states.Load(url.RawQuery) - var rps *responsePatternSequence - if !ok { - patterns, err := compilePatterns(query.Get("r")) - if err != nil { - return 400, err.Error() - } - rps = NewResponsePatternSequence(patterns, query.Get("shuffle") == "true") - states.Store(url.RawQuery, rps) - } else { - rps = rpsInter.(*responsePatternSequence) - } - - return rps.next() -} - -func NewResponsePatternSequence(patterns []*responsePattern, shuffle bool) *responsePatternSequence { - ps := responsePatternSequence{ - currentPatternIdx: 0, - currentPattern: patterns[0], - currentPatternCount: 0, - patterns: patterns, - shuffle: shuffle, - mtx: sync.Mutex{}, - } - - return &ps -} - -func compilePatterns(patternsStr string) (patterns []*responsePattern, err error) { - splitPatterns := strings.Split(patternsStr, ",") - - for _, patternStr := range splitPatterns { - rp, err := compilePattern(patternStr) - if err != nil { - return nil, err - } - patterns = append(patterns, rp) - } - - return patterns, nil -} - -func compilePattern(patternStr string) (*responsePattern, error) { - rp := responsePattern{} - - splitPattern := strings.Split(patternStr, "x") - if len(splitPattern) != 2 { - return nil, fmt.Errorf("bad pattern '%s', expected a STATUSxCOUNT as pattern", patternStr) - } - - statusDefStr := splitPattern[0] - if statusListRegexp.MatchString(statusDefStr) { - statuses := strings.Split(statusDefStr, "|") - for _, statusStr := range statuses { - status, _ := strconv.Atoi(statusStr) - rp.httpStatuses = append(rp.httpStatuses, status) - } - rp.httpStatusesLen = len(rp.httpStatuses) - } else { - return nil, fmt.Errorf("Expected a | separated list of numbers for status code def, got '%s'", statusDefStr) - - } - - count, err := strconv.Atoi(splitPattern[1]) - if err != nil { - return nil, fmt.Errorf("Repeat def should be an int, got '%s'", splitPattern[1]) - } - rp.countLimit = count - - return &rp, nil -} diff --git a/dev-tools/mage/integtest_docker.go b/dev-tools/mage/integtest_docker.go index ad595e608a30..8c5fb6d3603f 100644 --- a/dev-tools/mage/integtest_docker.go +++ b/dev-tools/mage/integtest_docker.go @@ -231,7 +231,6 @@ func GoIntegTestFromHost(ctx context.Context, params GoTestArgs) error { } // Run Go test from the host machine. Do not immediately exit on error to allow cleanup to occur. - params.ExtraFlags = append(params.ExtraFlags, "-v") testErr := GoTest(ctx, params) err = saveDockerComposeLogs(cwd, "goIntegTest") From 8ac7d40e54ec1f4489a359fce9142bca142cc560 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:17:05 -0500 Subject: [PATCH 040/102] Group imports --- .../monitors/wrappers/monitorstate/esloader_integration_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index a1b8ac6828f4..2e97765486ad 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -3,6 +3,7 @@ package monitorstate import ( "encoding/json" "fmt" + "github.com/elastic/go-elasticsearch/v8" "github.com/elastic/go-elasticsearch/v8/esapi" "github.com/gofrs/uuid" From d6ed34777e46c6c6165937e50a8a8e94fe46f85c Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:37:18 -0500 Subject: [PATCH 041/102] Cleanups --- .../wrappers/monitorstate/esloader.go | 4 +- .../monitorstate/esloader_integration_test.go | 46 +++++++++---------- .../wrappers/monitorstate/monitorstate.go | 45 +++++++++--------- .../monitorstate/monitorstate_test.go | 19 ++++---- .../monitors/wrappers/monitorstate/tracker.go | 2 +- 5 files changed, 58 insertions(+), 58 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader.go b/heartbeat/monitors/wrappers/monitorstate/esloader.go index 76eb35ee12bc..ec73fc4270ce 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader.go @@ -78,6 +78,8 @@ func MakeESLoader(esc *elasticsearch.Client, indexPattern string) StateLoader { return nil, nil } - return &sh.Hits.Hits[0].Source.State, nil + state := &sh.Hits.Hits[0].Source.State + + return state, nil } } diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 2e97765486ad..5f9f411ad1db 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -8,14 +8,14 @@ import ( "github.com/elastic/go-elasticsearch/v8/esapi" "github.com/gofrs/uuid" "github.com/stretchr/testify/require" - "sync" "testing" "time" "github.com/elastic/beats/v7/heartbeat/esutil" ) -func TestStates(t *testing.T) { +func TestStatesESLoader(t *testing.T) { + testStart := time.Now() etc := newESTestContext(t) // Create three monitors in ES, load their states, and make sure we track them correctly @@ -30,6 +30,7 @@ func TestStates(t *testing.T) { monID := etc.createTestMonitorStateInES(t, testStatus) // Since we've continued this state it should register the initial state ms := etc.tracker.getCurrentState(monID) + require.True(t, ms.StartedAt.After(testStart.Add(-time.Nanosecond)), "timestamp for new state is off") requireMSStatusCount(t, ms, testStatus, 1) // Write the state a few times, enough to guarantee a stable state @@ -92,11 +93,11 @@ func (etc *esTestContext) createTestMonitorStateInES(t *testing.T, s StateStatus mID := mUUID.String() mType := "testtyp" initState := newMonitorState(mID, s) - etc.setInitialState(t, mType, initState) + etc.setInitialState(t, mType, mID, initState) return mID } -func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *State) { +func (etc *esTestContext) setInitialState(t *testing.T, typ string, monitorID string, ms *State) { idx := fmt.Sprintf("synthetics-%s-%s", typ, etc.namespace) type Mon struct { @@ -110,7 +111,7 @@ func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *State) { State *State `json:"state"` }{ Ts: time.Now(), - Monitor: Mon{Id: ms.MonitorId, Type: typ}, + Monitor: Mon{Id: monitorID, Type: typ}, State: ms, }) @@ -122,28 +123,23 @@ func (etc *esTestContext) setInitialState(t *testing.T, typ string, ms *State) { require.NoError(t, err) } -var connOnce = &sync.Once{} - func integES(t *testing.T) (esc *elasticsearch.Client) { - connOnce.Do(func() { - var err error - esc, err = elasticsearch.NewClient(elasticsearch.Config{ - Addresses: []string{"http://127.0.0.1:9200"}, - Username: "admin", - Password: "testing", - }) - require.NoError(t, err) - respBody, err := esc.Cluster.Health() - healthRaw, err := esutil.CheckRetResp(respBody, err) - require.NoError(t, err) - - healthResp := struct { - Status string `json:"status"` - }{} - err = json.Unmarshal(healthRaw, &healthResp) - require.NoError(t, err) - require.Contains(t, []string{"green", "yellow"}, healthResp.Status) + esc, err := elasticsearch.NewClient(elasticsearch.Config{ + Addresses: []string{"http://127.0.0.1:9200"}, + Username: "admin", + Password: "testing", }) + require.NoError(t, err) + respBody, err := esc.Cluster.Health() + healthRaw, err := esutil.CheckRetResp(respBody, err) + require.NoError(t, err) + + healthResp := struct { + Status string `json:"status"` + }{} + err = json.Unmarshal(healthRaw, &healthResp) + require.NoError(t, err) + require.Contains(t, []string{"green", "yellow"}, healthResp.Status) return esc } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index a84dad035508..38855b6c958f 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -5,6 +5,10 @@ import ( "time" ) +// FlappingThreshold defines how many consecutive checks with the same status +// must occur for us to end a flapping state. FlappingThreshold-1 is the number +// of consecutive checks that is insufficient to start a new state, but rather to +// keep the current state and turn it into a flapping state. const FlappingThreshold = 3 type StateStatus string @@ -16,33 +20,30 @@ const ( ) func newMonitorState(monitorId string, status StateStatus) *State { - nowMillis := time.Now().UnixMilli() + now := time.Now() ms := &State{ - Id: fmt.Sprintf("%s-%x", monitorId, nowMillis), - MonitorId: monitorId, - StartedAtMs: float64(nowMillis), - Status: status, + Id: fmt.Sprintf("%s-%x", monitorId, now.UnixMilli()), + StartedAt: now, + Status: status, } - ms.recordCheck(status) + ms.recordCheck(monitorId, status) return ms } -type HistoricalStatus struct { - TsMs float64 `json:"ts_ms"` - Status StateStatus `json:"status"` -} - type State struct { - MonitorId string `json:"monitorId"` - Id string `json:"id"` - StartedAtMs float64 `json:"started_at_ms"` - Status StateStatus `json:"status"` - Checks int `json:"checks"` - Up int `json:"up"` - Down int `json:"down"` + Id string `json:"id"` + // StartedAt is the start time of the state, should be the same for a given state ID + StartedAt time.Time `json:"started_at"` + Status StateStatus `json:"status"` + Checks int `json:"checks"` + Up int `json:"up"` + Down int `json:"down"` + // FlapHistory retains enough info so we can resume our flap + // computation if loading from ES or another source FlapHistory []StateStatus `json:"flap_history"` - Ends *State `json:"ends"` + // Ends is a pointer to the prior state if this is the start of a new state + Ends *State `json:"ends"` } func (s *State) incrementCounters(status StateStatus) { @@ -73,7 +74,7 @@ func (s *State) truncateFlapHistory() { // If the current state is continued it just updates counters and other record keeping, // if the state ends it actually swaps out the full value the state points to // and sets state.Ends. -func (s *State) recordCheck(newStatus StateStatus) { +func (s *State) recordCheck(monitorId string, newStatus StateStatus) { if s.Status == StatusFlapping { s.truncateFlapHistory() @@ -92,7 +93,7 @@ func (s *State) recordCheck(newStatus StateStatus) { s.incrementCounters(newStatus) } else { // flap has ended oldState := *s - *s = *newMonitorState(s.MonitorId, newStatus) + *s = *newMonitorState(monitorId, newStatus) s.Ends = &oldState } } else if s.Status == newStatus { // stable state, status has not changed @@ -107,7 +108,7 @@ func (s *State) recordCheck(newStatus StateStatus) { // state has changed, but we aren't flapping (yet), since we've been stable past the // flapping threshold oldState := *s - *s = *newMonitorState(s.MonitorId, newStatus) + *s = *newMonitorState(monitorId, newStatus) s.Ends = &oldState } } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index d0803313413b..8d0aad0dde8c 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -6,15 +6,16 @@ import ( ) func TestRecordingAndFlapping(t *testing.T) { - ms := newMonitorState("test", StatusUp) - recordFlappingSeries(ms) + monitorID := "test" + ms := newMonitorState(monitorID, StatusUp) + recordFlappingSeries(monitorID, ms) require.Equal(t, StatusFlapping, ms.Status) require.Equal(t, FlappingThreshold+1, ms.Checks) require.Equal(t, ms.Up+ms.Down, ms.Checks) // Use double the flapping threshold so any transitions after this are stable priorChecksCount := ms.Checks - recordStableSeries(ms, FlappingThreshold*2, StatusDown) + recordStableSeries(monitorID, ms, FlappingThreshold*2, StatusDown) require.Equal(t, StatusDown, ms.Status) // The count should be FlappingThreshold+1 since we used double the threshold before // This is because we have one full threshold of stable checks, as well as the final check that @@ -25,7 +26,7 @@ func TestRecordingAndFlapping(t *testing.T) { require.Equal(t, priorChecksCount+FlappingThreshold-1, ms.Ends.Checks) // Since we're now in a stable state a single up check should create a new state from a stable one - ms.recordCheck(StatusUp) + ms.recordCheck(monitorID, StatusUp) require.Equal(t, StatusUp, ms.Status) require.Equal(t, 1, ms.Checks) require.Equal(t, 1, ms.Up) @@ -33,19 +34,19 @@ func TestRecordingAndFlapping(t *testing.T) { } // recordFlappingSeries is a helper that should always put the monitor into a flapping state. -func recordFlappingSeries(ms *State) { +func recordFlappingSeries(monitorID string, ms *State) { for i := 0; i < FlappingThreshold; i++ { if i%2 == 0 { - ms.recordCheck(StatusUp) + ms.recordCheck(monitorID, StatusUp) } else { - ms.recordCheck(StatusDown) + ms.recordCheck(monitorID, StatusDown) } } } // recordStableSeries is a test helper for repeatedly recording one status -func recordStableSeries(ms *State, count int, s StateStatus) { +func recordStableSeries(monitorID string, ms *State, count int, s StateStatus) { for i := 0; i < count; i++ { - ms.recordCheck(s) + ms.recordCheck(monitorID, s) } } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 373e3eb592aa..41e496b0b533 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -47,7 +47,7 @@ func (t *Tracker) RecordStatus(monitorId string, newStatus StateStatus) (ms *Sta state = newMonitorState(monitorId, newStatus) t.states[monitorId] = state } else { - state.recordCheck(newStatus) + state.recordCheck(monitorId, newStatus) } // return a copy since the state itself is a pointer that is frequently mutated return state.copy() From 79ac24a937a8c63bbdc6b4aa8c853e4c803566c9 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:42:51 -0500 Subject: [PATCH 042/102] Cleanups --- .../monitors/wrappers/monitorstate/monitorstate_test.go | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index 8d0aad0dde8c..dcf4ac0843fc 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -20,17 +20,13 @@ func TestRecordingAndFlapping(t *testing.T) { // The count should be FlappingThreshold+1 since we used double the threshold before // This is because we have one full threshold of stable checks, as well as the final check that // flipped us out of the threshold, which goes toward the new state. - require.Equal(t, FlappingThreshold+1, ms.Checks) - require.Equal(t, 0, ms.Up) - require.Equal(t, FlappingThreshold+1, ms.Down) + requireMSCounts(t, ms, 0, FlappingThreshold+1) require.Equal(t, priorChecksCount+FlappingThreshold-1, ms.Ends.Checks) // Since we're now in a stable state a single up check should create a new state from a stable one ms.recordCheck(monitorID, StatusUp) require.Equal(t, StatusUp, ms.Status) - require.Equal(t, 1, ms.Checks) - require.Equal(t, 1, ms.Up) - require.Equal(t, 0, ms.Down) + requireMSCounts(t, ms, 1, 0) } // recordFlappingSeries is a helper that should always put the monitor into a flapping state. From 102db3344f0de5d90ba2eb75dd092ff0ba34f5e5 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:44:58 -0500 Subject: [PATCH 043/102] Cleanups --- .../monitors/wrappers/monitorstate/tracker.go | 32 +++++++++---------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 41e496b0b533..3ddb1ed6e1cf 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -14,16 +14,14 @@ import ( // it will use ES if configured, otherwise it will only track state from // memory. func NewMonitorStateTracker(sl StateLoader) *Tracker { - t := &Tracker{ + if sl == nil { + sl = NilStateLoader + } + return &Tracker{ states: map[string]*State{}, mtx: sync.Mutex{}, stateLoader: sl, } - if t.stateLoader == nil { - t.stateLoader = NilStateLoader - } - - return t } type Tracker struct { @@ -34,27 +32,27 @@ type Tracker struct { // StateLoader has signature as loadLastESState, useful for test mocking, and maybe for a future impl // other than ES if necessary -type StateLoader func(monitorId string) (*State, error) +type StateLoader func(monitorID string) (*State, error) -func (t *Tracker) RecordStatus(monitorId string, newStatus StateStatus) (ms *State) { +func (t *Tracker) RecordStatus(monitorID string, newStatus StateStatus) (ms *State) { //note: the return values have no concurrency controls, they may be unsafely read unless //copied to the stack, copying the structs before returning t.mtx.Lock() defer t.mtx.Unlock() - state := t.getCurrentState(monitorId) + state := t.getCurrentState(monitorID) if state == nil { - state = newMonitorState(monitorId, newStatus) - t.states[monitorId] = state + state = newMonitorState(monitorID, newStatus) + t.states[monitorID] = state } else { - state.recordCheck(monitorId, newStatus) + state.recordCheck(monitorID, newStatus) } // return a copy since the state itself is a pointer that is frequently mutated return state.copy() } -func (t *Tracker) getCurrentState(monitorId string) (state *State) { - if state, ok := t.states[monitorId]; ok { +func (t *Tracker) getCurrentState(monitorID string) (state *State) { + if state, ok := t.states[monitorID]; ok { return state } @@ -62,7 +60,7 @@ func (t *Tracker) getCurrentState(monitorId string) (state *State) { var loadedState *State var err error for i := 0; i < tries; i++ { - loadedState, err = t.stateLoader(monitorId) + loadedState, err = t.stateLoader(monitorID) if err != nil { sleepFor := (time.Duration(i*i) * time.Second) + (time.Duration(rand.Intn(500)) * time.Millisecond) logp.L().Warnf("could not load last externally recorded state, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) @@ -70,11 +68,11 @@ func (t *Tracker) getCurrentState(monitorId string) (state *State) { } } if err != nil { - logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorId) + logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorID) } if loadedState != nil { - t.states[monitorId] = loadedState + t.states[monitorID] = loadedState } // Return what we found, even if nil From c7178ccef2cdc67eaaf1b13b9cd848d5b3f53794 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:46:56 -0500 Subject: [PATCH 044/102] Cleanups --- .../monitors/wrappers/monitorstate/tracker_test.go | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index a2f02da87c67..37dd318e301d 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -10,21 +10,15 @@ func TestTrackerRecord(t *testing.T) { mst := NewMonitorStateTracker(NilStateLoader) ms := mst.RecordStatus(monId, StatusUp) require.Equal(t, StatusUp, ms.Status) - require.Equal(t, 1, ms.Checks) - require.Equal(t, 1, ms.Up) - require.Equal(t, 0, ms.Down) + requireMSCounts(t, ms, 1, 0) for i := 0; i < FlappingThreshold; i++ { ms = mst.RecordStatus(monId, StatusUp) } require.Equal(t, StatusUp, ms.Status) - require.Equal(t, 4, ms.Checks) - require.Equal(t, 4, ms.Up) - require.Equal(t, 0, ms.Down) + requireMSCounts(t, ms, 4, 0) ms = mst.RecordStatus(monId, StatusDown) require.Equal(t, StatusDown, ms.Status) - require.Equal(t, 1, ms.Checks) - require.Equal(t, 0, ms.Up) - require.Equal(t, 1, ms.Down) + requireMSCounts(t, ms, 0, 1) } From a7ff0e2233794975af9db2c17de40926f6000ede Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:48:12 -0500 Subject: [PATCH 045/102] Cleanups --- .../wrappers/monitorstate/esloader_integration_test.go | 2 +- heartbeat/monitors/wrappers/monitorstate/tracker.go | 4 ++-- heartbeat/monitors/wrappers/monitorstate/tracker_test.go | 2 +- heartbeat/monitors/wrappers/wrappers.go | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 5f9f411ad1db..5a1b1c1650b5 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -83,7 +83,7 @@ func newESTestContext(t *testing.T) *esTestContext { loader: MakeESLoader(esc, fmt.Sprintf("synthetics-*-%s", namespace.String())), } - etc.tracker = NewMonitorStateTracker(etc.loader) + etc.tracker = NewTracker(etc.loader) return etc } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 3ddb1ed6e1cf..62c4ec437b63 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -8,12 +8,12 @@ import ( "github.com/elastic/elastic-agent-libs/logp" ) -// NewMonitorStateTracker tracks state across job runs. It takes an optional +// NewTracker tracks state across job runs. It takes an optional // state loader, which will try to fetch the last known state for a never // before seen monitor, which usually means using ES. If set to nil // it will use ES if configured, otherwise it will only track state from // memory. -func NewMonitorStateTracker(sl StateLoader) *Tracker { +func NewTracker(sl StateLoader) *Tracker { if sl == nil { sl = NilStateLoader } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index 37dd318e301d..15fb15cd8a57 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -7,7 +7,7 @@ import ( func TestTrackerRecord(t *testing.T) { monId := "mymonitor" - mst := NewMonitorStateTracker(NilStateLoader) + mst := NewTracker(NilStateLoader) ms := mst.RecordStatus(monId, StatusUp) require.Equal(t, StatusUp, ms.Status) requireMSCounts(t, ms, 1, 0) diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index c467b6913b1f..583da4651fb9 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -43,7 +43,7 @@ import ( // WrapCommon applies the common wrappers that all monitor jobs get. func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, stateLoader monitorstate.StateLoader) []jobs.Job { - mst := monitorstate.NewMonitorStateTracker(stateLoader) + mst := monitorstate.NewTracker(stateLoader) if stdMonFields.Type == "browser" { return WrapBrowser(js, stdMonFields, mst) } else { From 1ab5ff54c5389cc2d145f7b9eb3bc1569a15ef35 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:49:00 -0500 Subject: [PATCH 046/102] Cleanups --- heartbeat/monitors/wrappers/wrappers.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 583da4651fb9..e8d2efe94cb3 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -18,7 +18,6 @@ package wrappers import ( - "encoding/json" "errors" "fmt" "sync" @@ -93,7 +92,6 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.Tracker) j if !hasSummary { return cont, err } - logp.Warn("TERMINAL DOC FOR %s", sf.ID) status, err := event.GetValue("monitor.status") if err != nil { @@ -102,11 +100,7 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.Tracker) j ms := mst.RecordStatus(sf.ID, monitorstate.StateStatus(status.(string))) - logp.Warn("CHECKS: %s - s:%s u:%d d:%d", sf.ID, ms.Status, ms.Up, ms.Down) - eventext.MergeEventFields(event, mapstr.M{"state": ms}) - f, _ := json.Marshal(event.Fields) - logp.Info("SUMMARY %s", f) return cont, nil } @@ -365,7 +359,6 @@ func makeAddSummary() jobs.JobWrapper { resetState() } - logp.Warn("RET CONT %s %d / %s", state.checkGroup, len(cont), jobErr) return cont, jobErr } } From 1163d538a39f81d9146010a5190fe2577d759fe1 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 21:56:23 -0500 Subject: [PATCH 047/102] Cleanups --- x-pack/heartbeat/magefile.go | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/x-pack/heartbeat/magefile.go b/x-pack/heartbeat/magefile.go index 804fcf773de3..829d8ec7016c 100644 --- a/x-pack/heartbeat/magefile.go +++ b/x-pack/heartbeat/magefile.go @@ -16,6 +16,7 @@ import ( "github.com/magefile/mage/mg" devtools "github.com/elastic/beats/v7/dev-tools/mage" + "github.com/elastic/beats/v7/dev-tools/mage/target/test" heartbeat "github.com/elastic/beats/v7/heartbeat/scripts/mage" // mage:import @@ -26,13 +27,14 @@ import ( // mage:import _ "github.com/elastic/beats/v7/dev-tools/mage/target/unittest" // mage:import - _ "github.com/elastic/beats/v7/dev-tools/mage/target/integtest/notests" + _ "github.com/elastic/beats/v7/dev-tools/mage/target/integtest/docker" // mage:import _ "github.com/elastic/beats/v7/dev-tools/mage/target/test" ) func init() { common.RegisterCheckDeps(Update) + test.RegisterDeps(IntegTest) devtools.BeatLicense = "Elastic License" } @@ -77,9 +79,12 @@ func Update() { mg.SerialDeps(Fields, FieldDocs, Config) } -func HintegTest() error { - fmt.Println("Running heartbeat go integ tests") - return devtools.GoIntegTestFromHost(context.Background(), devtools.DefaultGoTestIntegrationFromHostArgs()) +func IntegTest() { + mg.SerialDeps(GoIntegTest) +} + +func GoIntegTest(ctx context.Context) error { + return devtools.GoIntegTestFromHost(ctx, devtools.DefaultGoTestIntegrationFromHostArgs()) } func Fields() error { From cf99c890551704a5ca906a1ac8ff5749ca1b407a Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 22:21:21 -0500 Subject: [PATCH 048/102] Update and add run xml --- heartbeat/_meta/fields.common.yml | 114 ++++++++------- heartbeat/docs/fields.asciidoc | 136 ++++++++++-------- .../monitorstate/esloader_integration_test.go | 14 +- .../wrappers/monitorstate/monitorstate.go | 4 +- ...heartbeat x-pack docker compose up.run.xml | 23 +++ x-pack/heartbeat/include/fields.go | 2 +- 6 files changed, 168 insertions(+), 125 deletions(-) create mode 100644 x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 5c561cb311ff..23f2564be17f 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -81,6 +81,23 @@ description: > Time range this ping reported starting at the instant the check was started, ending at the start of the next scheduled check. + - name: origin + type: keyword + description: > + The origin of this monitor configuration, usually either "ui", or "project" + + - name: project + type: group + description: > + Project info for this monitor + fields: + - name: id + type: keyword + description: Project ID + - name: name + type: keyword + description: Project name + - key: state title: "Monitor state" description: state related fields @@ -90,76 +107,57 @@ description: "Present in the last event emitted during a check. If a monitor checks multiple endpoints, as is the case with `mode: all`." fields: - name: id - type: long - description: > - ID of this state - - name: status - type: keyword - description: > - The current status of this state at the time of this event, can changed from up->flapping or down->flapping at any time - - name: starting - type: group - fields: - - name: id - type: long - description: > - ID of this state - - name: started_at - type: date - description: > - Time this state started at - - name: status type: keyword - description: > - Time this state started at - - name: ending - type: group - fields: - - name: id - type: long description: > ID of this state - name: started_at type: date description: > - Time this state started at - - name: ended_at - type: date - description: > - Time this state started at + First time state with this ID was seen - name: status type: keyword description: > - Time this state started at + The current status, "up", "down", or "flapping" + any state can change into flapping. - name: checks - type: long - description: - total checks within this state + type: integer + description: total checks run - name: up - type: long - description: > - total number of up checks + type: integer + description: total up checks run - name: down - type: long - description: > - total number of up checks - - name: origin - type: keyword - description: > - The origin of this monitor configuration, usually either "ui", or "project" - - - name: project - type: group - description: > - Project info for this monitor - fields: - - name: id - type: keyword - description: Project ID - fields: - - name: name - type: keyword - description: Project name + type: integer + description: total down checks run + - name: flap_history + enabled: false + - name: ends + type: group + description: the state that was ended by this state + fields: + - name: id + type: integer + description: > + ID of this state + - name: started_at + type: date + description: > + First time state with this ID was seen + - name: status + type: keyword + description: > + The current status, "up", "down", or "flapping" + any state can change into flapping. + - name: checks + type: integer + description: total checks run + - name: up + type: integer + description: total up checks run + - name: down + type: integer + description: total down checks run + - name: flap_history + enabled: false - key: summary title: "Monitor summary" diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index b90f7137073b..75817833572f 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -469,6 +469,41 @@ type: date_range -- +*`monitor.origin`*:: ++ +-- +The origin of this monitor configuration, usually either "ui", or "project" + + +type: keyword + +-- + +[float] +=== project + +Project info for this monitor + + + +*`monitor.project.id`*:: ++ +-- +Project ID + +type: keyword + +-- + +*`monitor.project.name`*:: ++ +-- +Project name + +type: keyword + +-- + [[exported-fields-docker-processor]] == Docker fields @@ -16293,144 +16328,131 @@ Present in the last event emitted during a check. If a monitor checks multiple e ID of this state -type: long +type: keyword -- -*`state.status`*:: +*`state.started_at`*:: + -- -The current status of this state at the time of this event, can changed from up->flapping or down->flapping at any time +First time state with this ID was seen -type: keyword +type: date -- - -*`starting.id`*:: +*`state.status`*:: + -- -ID of this state +The current status, "up", "down", or "flapping" any state can change into flapping. -type: long +type: keyword -- -*`starting.started_at`*:: +*`state.checks`*:: + -- -Time this state started at - +total checks run -type: date +type: integer -- -*`starting.status`*:: +*`state.up`*:: + -- -Time this state started at +total up checks run - -type: keyword +type: integer -- - -*`ending.id`*:: +*`state.down`*:: + -- -ID of this state - +total down checks run -type: long +type: integer -- -*`ending.started_at`*:: +*`state.flap_history`*:: + -- -Time this state started at +Object is not enabled. +-- -type: date +[float] +=== ends + +the state that was ended by this state --- -*`ending.ended_at`*:: +*`ends.id`*:: + -- -Time this state started at +ID of this state -type: date +type: integer -- -*`ending.status`*:: +*`ends.started_at`*:: + -- -Time this state started at +First time state with this ID was seen -type: keyword +type: date -- -*`ending.checks`*:: +*`ends.status`*:: + -- -total checks within this state +The current status, "up", "down", or "flapping" any state can change into flapping. -type: long + +type: keyword -- -*`ending.up`*:: +*`ends.checks`*:: + -- -total number of up checks +total checks run - -type: long +type: integer -- -*`ending.down`*:: +*`ends.up`*:: + -- -total number of up checks +total up checks run - -type: long +type: integer -- -*`ending.origin`*:: +*`ends.down`*:: + -- -The origin of this monitor configuration, usually either "ui", or "project" - +total down checks run -type: keyword +type: integer -- -[float] -=== project - -Project info for this monitor - - - -*`ending.project.name`*:: +*`ends.flap_history`*:: + -- -Project name - -type: keyword +Object is not enabled. -- diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 5a1b1c1650b5..ca81e68a6e9b 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -39,9 +39,9 @@ func TestStatesESLoader(t *testing.T) { for i := 0; i < count; i++ { ms = etc.tracker.RecordStatus(monID, testStatus) if i == 0 { - lastId = ms.Id + lastId = ms.ID } - require.Equal(t, lastId, ms.Id, "state ID should not change within state") + require.Equal(t, lastId, ms.ID, "state ID should not change within state") } // The initial state adds 1 to count requireMSStatusCount(t, ms, testStatus, count+1) @@ -53,15 +53,15 @@ func TestStatesESLoader(t *testing.T) { testStatus = StatusUp } - origMsId := ms.Id + origMsId := ms.ID for i := 0; i < count; i++ { ms = etc.tracker.RecordStatus(monID, testStatus) - require.NotEqual(t, origMsId, ms.Id) + require.NotEqual(t, origMsId, ms.ID) if i == 0 { - lastId = ms.Id - require.Equal(t, origMsId, ms.Ends.Id, "transition should point to the prior state") + lastId = ms.ID + require.Equal(t, origMsId, ms.Ends.ID, "transition should point to the prior state") } - require.Equal(t, lastId, ms.Id, "state ID should not change within state") + require.Equal(t, lastId, ms.ID, "state ID should not change within state") } requireMSStatusCount(t, ms, testStatus, count) } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 38855b6c958f..378ec297a307 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -22,7 +22,7 @@ const ( func newMonitorState(monitorId string, status StateStatus) *State { now := time.Now() ms := &State{ - Id: fmt.Sprintf("%s-%x", monitorId, now.UnixMilli()), + ID: fmt.Sprintf("%s-%x", monitorId, now.UnixMilli()), StartedAt: now, Status: status, } @@ -32,7 +32,7 @@ func newMonitorState(monitorId string, status StateStatus) *State { } type State struct { - Id string `json:"id"` + ID string `json:"id"` // StartedAt is the start time of the state, should be the same for a given state ID StartedAt time.Time `json:"started_at"` Status StateStatus `json:"status"` diff --git a/x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml b/x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml new file mode 100644 index 000000000000..c87758cc4fa2 --- /dev/null +++ b/x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml @@ -0,0 +1,23 @@ + + + + + + + + + + \ No newline at end of file diff --git a/x-pack/heartbeat/include/fields.go b/x-pack/heartbeat/include/fields.go index 9b07f2a5c264..8b3bf6c5c7c8 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } From 007b607e6dd6e62ac8754767a6f2821c3a71c8a8 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 22:24:19 -0500 Subject: [PATCH 049/102] Cleanups --- heartbeat/_meta/fields.common.yml | 6 ------ heartbeat/docs/fields.asciidoc | 10 ---------- x-pack/heartbeat/include/fields.go | 2 +- 3 files changed, 1 insertion(+), 17 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 23f2564be17f..21bf67b29790 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -70,12 +70,6 @@ description: > A token unique to a simultaneously invoked group of checks as in the case where multiple IPs are checked for a single DNS entry. - - name: status_block - type: date - description: > - A date representing the start time of a logically contiguous segment of statuses typically either all up - or all down. In the case of a rapidly flapping endpoint this may be a mix. - - name: timespan type: date_range description: > diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index 75817833572f..9761ff72bfe1 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -449,16 +449,6 @@ type: keyword -- -*`monitor.status_block`*:: -+ --- -A date representing the start time of a logically contiguous segment of statuses typically either all up or all down. In the case of a rapidly flapping endpoint this may be a mix. - - -type: date - --- - *`monitor.timespan`*:: + -- diff --git a/x-pack/heartbeat/include/fields.go b/x-pack/heartbeat/include/fields.go index 8b3bf6c5c7c8..107b7d205d4a 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } From 701f48ca7763f88c78f40d2c2db2deaf5c78a546 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 22:25:27 -0500 Subject: [PATCH 050/102] More inclusive index pattern --- heartbeat/beater/heartbeat.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 1513f4d9488c..a722e047d976 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -67,7 +67,7 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { } var stateLoader monitorstate.StateLoader if esc != nil { - stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*") + stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*") } else { stateLoader = monitorstate.NilStateLoader } From 00199f870c37267fb720533c590b13e7af00f97c Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 22:53:39 -0500 Subject: [PATCH 051/102] More inclusive index pattern --- heartbeat/include/fields.go | 2 +- heartbeat/monitors/wrappers/wrappers.go | 8 ++++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index ce58801aa54c..ea339d974dfb 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index e8d2efe94cb3..0b1fffd6e4eb 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -60,11 +60,15 @@ func WrapLightweight(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, mst addMonitorMeta(stdMonFields, len(js) > 1), addMonitorStatus(false), addMonitorDuration, - addMonitorState(stdMonFields, mst), ), func() jobs.JobWrapper { return makeAddSummary() - }) + }, + func() jobs.JobWrapper { + return addMonitorState(stdMonFields, mst) + }, + ) + } // WrapBrowser is pretty minimal in terms of fields added. The browser monitor From 0247783dd90d9fcfad09a93f1871e51df2511682 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 23:27:37 -0500 Subject: [PATCH 052/102] Tweaks --- heartbeat/_meta/fields.common.yml | 8 ++++++++ heartbeat/docs/fields.asciidoc | 20 +++++++++++++++++++ heartbeat/ecserr/ecserr.go | 8 ++++++++ heartbeat/include/fields.go | 2 +- heartbeat/monitors/active/http/check.go | 3 ++- .../wrappers/monitorstate/monitorstate.go | 19 ++++++++++-------- x-pack/heartbeat/include/fields.go | 2 +- 7 files changed, 51 insertions(+), 11 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 21bf67b29790..0e01df9f51fe 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -108,6 +108,10 @@ type: date description: > First time state with this ID was seen + - name: duration_ms + type: date + description: > + Length of time this state has existed in millis - name: status type: keyword description: > @@ -136,6 +140,10 @@ type: date description: > First time state with this ID was seen + - name: duration_ms + type: date + description: > + Length of time this state has existed in millis - name: status type: keyword description: > diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index 9761ff72bfe1..beb7dd550470 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -16328,6 +16328,16 @@ type: keyword First time state with this ID was seen +type: date + +-- + +*`state.duration_ms`*:: ++ +-- +Length of time this state has existed in millis + + type: date -- @@ -16398,6 +16408,16 @@ type: integer First time state with this ID was seen +type: date + +-- + +*`ends.duration_ms`*:: ++ +-- +Length of time this state has existed in millis + + type: date -- diff --git a/heartbeat/ecserr/ecserr.go b/heartbeat/ecserr/ecserr.go index 6755abeae406..13b2aed14741 100644 --- a/heartbeat/ecserr/ecserr.go +++ b/heartbeat/ecserr/ecserr.go @@ -89,3 +89,11 @@ func NewSyntheticsCmdCouldNotStartErr(reason error) *ECSErr { fmt.Sprintf("could not start command not found: %s", reason), ) } + +func NewBadHTTPStatusErr(code int, statusText string) *ECSErr { + return NewECSErr( + ETYPE_IO, + "BAD_HTTP_STATUS", + fmt.Sprintf("Bad HTTP status %s encountered", statusText), + ) +} diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index ea339d974dfb..22c17c22dcb2 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/heartbeat/monitors/active/http/check.go b/heartbeat/monitors/active/http/check.go index e1a2e67b0249..013ebb7711e3 100644 --- a/heartbeat/monitors/active/http/check.go +++ b/heartbeat/monitors/active/http/check.go @@ -22,6 +22,7 @@ import ( "fmt" "net/http" + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/reason" "github.com/elastic/beats/v7/libbeat/common/match" ) @@ -120,7 +121,7 @@ func checkStatus(status []uint16) respValidator { func checkStatusOK(r *http.Response) error { if r.StatusCode >= 400 { - return errors.New(r.Status) + return ecserr.NewBadHTTPStatusErr(r.StatusCode, r.Status) } return nil } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 378ec297a307..85a68277eacd 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -22,9 +22,10 @@ const ( func newMonitorState(monitorId string, status StateStatus) *State { now := time.Now() ms := &State{ - ID: fmt.Sprintf("%s-%x", monitorId, now.UnixMilli()), - StartedAt: now, - Status: status, + ID: fmt.Sprintf("%s-%x", monitorId, now.UnixMilli()), + StartedAt: now, + DurationMs: 0, + Status: status, } ms.recordCheck(monitorId, status) @@ -34,11 +35,12 @@ func newMonitorState(monitorId string, status StateStatus) *State { type State struct { ID string `json:"id"` // StartedAt is the start time of the state, should be the same for a given state ID - StartedAt time.Time `json:"started_at"` - Status StateStatus `json:"status"` - Checks int `json:"checks"` - Up int `json:"up"` - Down int `json:"down"` + StartedAt time.Time `json:"started_at"` + DurationMs int64 `json:"duration_ms"` + Status StateStatus `json:"status"` + Checks int `json:"checks"` + Up int `json:"up"` + Down int `json:"down"` // FlapHistory retains enough info so we can resume our flap // computation if loading from ES or another source FlapHistory []StateStatus `json:"flap_history"` @@ -47,6 +49,7 @@ type State struct { } func (s *State) incrementCounters(status StateStatus) { + s.DurationMs = time.Until(s.StartedAt).Milliseconds() s.Checks++ if status == StatusUp { s.Up++ diff --git a/x-pack/heartbeat/include/fields.go b/x-pack/heartbeat/include/fields.go index 107b7d205d4a..a2f1cc5231ee 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "eJzsvft7GzeyKPh7/gqsZr+VlEO2SL0sa+/sXkWSE33HD40lT+Yknk8Eu0ESoybQAdCSmbPnf98PVQAa/ZBMyaJjZ3xvjociu4GqQqFQVajHX8jPR29fn73+8f8gJ5IIaQjLuCFmxjWZ8JyRjCuWmnzRI9yQW6rJlAmmqGEZGS+ImTFyenxBCiX/xVLT++4vZEw1y4gU8P0NU5pLQQ6SQTLoZ+wm+e4v5DxnVDNywzU3ZGZMoQ+3tqbczMpxksr5FsupNjzdYqkmRhJdTqdMG5LOqJgy+MoOPeEsz3Ty3Xd9cs0Wh4Sl+jtCDDc5O7QPfEdIxnSqeGG4FPAVeeHeIe7tw+8I6RNB5+yQrP9vw+dMGzov1r8jhJCc3bD8kKRSMfhbsd9Krlh2SIwq8SuzKNghyajBP2vzrZ9Qw7bsmOR2xgSQit0wYYhUfMqFJWHyHbxHyKWlN9fwUBbeYx+Moqkl9UTJeTVCz07MU5rnC6JYoZhmwnAxhYnciNV0nYumZalSFuY/m0Qv4G9kRjUR0kObk0CeHrLHDc1LBkAHYApZlLmdxg3rJptwpQ283wBLsZTxmwqqghcs56KC662jOa4XmUhFaJ7jCDrBdWIf6Lywi76+PRju9wd7/e2dy8HB4WDvcGc3Odjb+WXdrc6Elrm5gqHCIvrlz+mY5bpz4XGV5dhyOHyBH6/w+2u2uJUq62CA41IbObcPbCGtCsqVDrgdU0HGjJR2uxhJaJaROTOUcDGRak7tIPZ7hyu5mMkyz2CLplIYygURTNslRXCAre3/O8pzXBtNqGJEG2kJSLWHNABw6gk3ymR6zdSIUJGR0fWBHjlytCj832u0KHKeAnRrh2RtImV/TNVaj6wxcWO/KZTMyhR+/59lCD9nWtMpu4fyc2rS2ZUU+eLKsA+mg9IvpCK5nDpaASu5YR3jOIrhT/ZJ93OPyMLwOf89sKxlsRvObu124oJQeNp+wVQgnJ1OG1WmprSkzeVUk1tuZrI0hIpqx9Rg6BFpZkw5yUNSXP1UipQaJqJNY6QFYk4omZVzKvqK0YyOc0Z0OZ9TtSAy2qzxDp6XueFFHnDXhH3g2kqLGVtUE87HXLCMcGEkkSI83Vzrn1ieS/KzVHm2xCoaOr1v88SbhE+FVOyKjuUNOyTDwfZue0Vfcm0snu49HXaJoVPCaDrz2NfZ89eY+5Alt9f+uQwX0ikTyFnuBDkKX0yVLItDst3Bd5czhm+GVXU708lxSujYMgVK3Im5tRvSympjz9OJWzoqFnaNqN3YeW63co9kzOAHqYgca6Zu7HIie0vLljNpV1YqYug102TOqC4Vm9sH3LDhseaG14SLNC8zRn5g1IoWwFWTOV0QmmtJVCns225epRM4PAHR5HuHqhtSz6w8HrNK9MNOsPBTnmvPq0gkVQph95VEAlnYIvyUG/J2xlR8UMxoUTDLsRZZ2NkBVThELAGE496JlEZIY3nBI3tIznC61CodcoJIwz63G7dXwZdYViBO8RkzapJovx+dvwIVyB3SdYTcitOi2LKo8JQlpOKNWKBnknnSgSQHnYbwCXIL18Qe5cTMlCynM/JbyUo7vl5ow+aa5Pyakf+kk2vaI29ZxpE/CiVTpjUXU78o7nFdpjMr+F/KqTZUzwjiQS6A3I5kuEGBye/ZJ7HGVO2accnzLPHyzs3elABdMuBOKdDcYacfDBOZ1RDsVDVSThw/4Np5Hne6FIp9q1QJN4CRYXdSsegYD3YgxYVAFSgMaXdGoeQNz1jP6kS6YCmf8JTg26B7cR00REfZSDLNmVE8tTwVVOJnyX4yIBt0nu3vbvZIzsfwM3796z7d3mEHk4PJzmCyNxgMx3Rnd5ftsr3d7CB7no4PttPxcPAsDSBafAzZHmwP+oPt/mCPbO8cDgeHwwH5j8FgMCDvLo//GShcW+EJzTWrLSsrZmzOFM2veFZfVOaW4wkW1s9BeGYl4oQzhdKCa7dvNvgEDig4xfRmc4m5VYbUHBRPbxvQVEltF0Ibqqz4HJeGjJBDeDaC7Wc3XnuFDuiuJfSkRogm+k/D0+8E/81qzg/HO2hsViKhHIP3bkE1HDMCUot3MKBDL6uhZ/9dBYJO8QVxGh8ArRXUhOJTePqhhjLlNww0Xyrca/i0+3nG8mJS5lZmWgngMAwDm1tJXjj5TbjQhorUacKN40fbieEMskzitC1SaVusoAokQxibayIYy9C8vZ3xdNaeKgjyVM7tZNZyi/A+m1j54Q8aQBVPIP+VnBgmSM4mhrB5YRbtpZxIWVtFu1CrWMXLRXHP8vnDzU5AaH5LF5poY/8NtLXWhJ551sRldYYevmuVuqQijQhHdKBq9SyyuJtozKpHQGPhk9rCVyvWZIDa4s9pOrPWZpvE8Tiezk5wr4DUf3dHQp3YDZj2wYWi0u1Ya9U1lbU0Usi5LDW5AA3gI+rrkSC0egWVBrJxdLGJG9Mpow6wVArBwBdxJgxTghlyrqSRqfTn/sbZ+SZRsoTTsFBswj8wTUqRMTyn7emrZG4Hs9JNKjKXihHBzK1U10QWTFEjldVvvfuAzWg+sS9QYtWbnBGazbng2tideeN1aTtWJueoeFNDnEcEkZjPpeiRNGdU5YvqBAQbKEArc54uwL6YMVAZLILJJ+tHopyPg1573xGay6C81ZbIHRU4DqF5LlPQsR2kreVzamf4OmwEt7puoI2ji9ebpITB80V1Emm0rcKS4F45q9EjYsnh3nD/eQ1hqaZU8N9BbCbt4+VT1Aewbq9iKkci0LsFyL1Og47lq5SfBuXfRJjALC3sf5TScuTLl8fRjkxz3jAkj6tv7rEkj9ybdut57qTasSM33O4M3Ah+cdyGdJqwBw4tRMWmVGVgOVjDQArdi55Hq2HM0bXLpaA5meTyliiWWmO75ue4PD53o+I5VYHZgs1+YR+PIIPtqJkI9qJ95uK/XpOCptfMbOjNBGZB10jhBEprKnRfWkWvNqk3dBVo3kxbOJwp5qlkFBWaAjAJuZBzFoyjUqORaZiakzXvk5VqrXLDKDbxssuBIhoIatxw7mfnBMCVHbNgBIMTICKA24wWLDH1y1xNEcOPbg7HRH4Ce5aVurQEcaNW1jcXFrx/lQIXAIxxNK+9x7xjsIq+QprWkFbNwvXqwz72LsngyMTxtvw8wSUNmwcVN5plRLM5FYancBKwD8bpeOwDau89VKm8HNBB0zOS3HCLLv+dVZ4ViyhTYM9pbkrqluNsQhayVGGOCc1zz3z+fLAydCrVomcf9SqKNjzPCRO6VE4fdX5wq8ZkTBvLHpaklmATnudBjNGiULJQnBqWL57AqqZZppjWq7K8YBega8XxnJvQaUlB/MzHfFrKUucL5HJ4JwjSW0suLecM7gVIzjU4P8/Oe9aIxtNYKkLtMfOBaGn5JyHkvyqKB62x0qFwfyh662Hy+2GUuC9GSLK6LioIN5GqmZXoo8aDcpTwYmRBGSUI1qhHMlYwkTljADV5KSogwM/jVrLStZJ/u+Oc6uTf9kSPvFwLw/RH1P5oxdEnVH+tBsgP9gd09IV7PbcTHSOgIG0v0MFuDTBk55XYflbK4h6OrXgHpWPOhjWPd1xzurBbED3P8LKVB5PSHi6/WRk+4SyLxwZlhArUAOxLYVRB0YIGeuJWqObImLIGQCBguHTxd6wARZa5y9MwKBOKp7O5PVW7LOvE/ZGk7h1P6ymTScrN4mpFTpNja8d0cuUrazcx516tgSOF4YIJc5XKbBUwXd7Kfs6MYfY4zVj9rjnMvq674X599N1HNmg3Misi8OuYj/1kbaClMjNyNGeKp7QDyFIYtbjiWq6K5sc4BTm7eANEb0F4fHQnWKtiTQdS5yofU0GzNqXgZPu4t2TK5FUheVAr6peAUky5KTNUwXJq4I8WBOv/TdZyuI3uP9tJ9oe7BzuDHlnLqVk7JLt7yd5g7/nwgPzPegvIpz3OGk5ezVTfq1LRT2jEefL0iHNyoWItJ2SqqChzqrhZxDrRgqRWNwNLIhK8x17lCS5E5HCuUElOmT3snT01yaVUTmfogctsxitrpVIuELycFLOF5vaDv7FMvYzSEQivpYkiQOCelqNjaQ66zZRJj21b4o6lNlL0s7S1NoXUhuar2mXr5zA8ijWqtUx5dXeJMQIO5ArRv7uYikrbd1dQ4bopXKCOGbkW8lZY244SiwpMJBX55eycRDgRYG1QpW+oWpBbnlkNDk41t6vx4go+tun3fHewO3iImFVsyqVYpQB7CzPcJ7/6fzu+C64VSTAHU6cA+1vJxqzNf9aq+b2yCZ70WJ0xDIb6HfygkxrD9cKt7dnR66PouU7g3UG1daSmcCzTrR9KJqS+OuIqUj4/whi8+AiW4YEaHmfnwUqr64cbZ+c3u5bbz85v9jeT2lxzmq5iP786Ou4GpnFpIaQJt8dz6hTwty+OybPB7jbcv2O0IcsOyak1nmRqmCEb4BDgukcO+mNeqahWx9/Eq1+nGrlgtltJfi2LgqmUavZPMmMfaMZSPqc5yfiUG7j7sWqU8VptGNOBjxNbASJIKTSfuqAdNmUqIRdlCnf+N+5BF+uFd1YIAw0jzhbFjHVI38GgPxj0907h353+9k5tpQQ1SZMzOs/Hbu5Yv1RUaPQgnZ1brJw/BQNEXx9dBuck2WDJNHF+dyuVK5cpQU+cd8nXLoHDoRP544hRFC5qxJTkkmZkTHMqUjgDJ1yxW5rn6P9UsrRHY8PKt0gXUpmHGfne5NNG8W7LP6aGHf9roQf6/R5g/dawPse3H2XrbtfhaK3JMib43etx7tYgFhTxfPY80oYpll11WdlPpydaoTTj0xnTJprU0wjn7gEiRcEyD7Iux/hTtP4vqttw1Pei4Zy9bfWVtYaVu2bF11r8Rbdh767fM2aYmoNWWyiWcm31FVCbKPoAIUYJgnnLcc5TosvJhH8II8IzGzNjisOtLXwEn0ikmm4m5FItQCxKVLQ+cKtFopI1XhDN50W+IIZeV+uKPsOcagNiFyNXUacS0hBwfd2yPAfsL1+eVHFRa6lMyuu1tmC8ywkQyL5KbgiTANMHk+EeF4qP54tU+Dz3rAL6OmEfUlaYKuwOXqvuZlvsnsB9PCUFVYZHFw2kBQEID45z2f9zv6M2U9k1YICUdk3szCkV1U0DqfNVL6JAiNttITRmubztZvPuPVHfNzFt125vbxNGtUnmCzcCMgbuDKrNWhSlgEC4UWZUV2G3gCuoH2GaSptb0+V4O9HleFjbfL0aE1fgoUHhXNo+bq0aY62He05IK+B5DpfYTHHZEfpjEVhWEzSyuAI0PoPUY5OJPaRumJ3VMYrDfoNdvjzZ7KExFSypiu6BaCg6ev46EoSAZVnPK9EmSdoCsjlvGDYKLLKrBHzwdUtGkIp3CcVqJZYTj/B9jW9KzVSyWpaJ/Xd4cy0V3gfbyTFkZc7gPkRO7joWqSAvT47OIRAWMT4JQ8W8st7Gjs0pz1eE3DuLAUzgjZikDYCVnh0G8ld0A2PRXNfVMQBOKHpDeU7HeYdxm4+ZMuSUC22YY6waReB69Q9jO5h99XyHSK4sELcdjOrjqhE/Hy8HVz5bRU6NVa472BPhXKFLNV4JnKwNxIzq2ao4wVEKpI2dBx1zSjFr1bUi06kTS4JQIcUiTjFC+yRilXeauYjWEWDBM7yvhj8sdqOgAqRSTHCtaF6bk4qsQ6uCCMsOplpJYPMdcc1IstbuvugP+3v97WF/e7C9u737fLj97OBZf3v/+fbu9vPdwW5/e2dv+Hxv/9nBfn84GAzaSDyds/Azy8GLmbU+0V0PWShc3EsqmrA7ZaCSefNy+slY/kgpCulmwMowk7+vAL9kPRGtAfT6r2vXfEwFvYKYzbUeWVMMtG4xvbID+sSsO+lWxdTJEgEPIXX+i7sj6jDVl+DuDBEWMBQYLGKiaMjhq9BAPxrGbntnAkRwkzuziybkVZXdwXUcZk4FOT3eRovLbtAJM+mMabibiUYn3GiX0FUBaTd3PW+xllDGdQhfroPgxlWlcJliis2lCcHORJZG84xFMzUhQ5gocalMHiHPOqJ61d0r1VMscdBqIMjZcpN7h48dlusKVEewKB/aA+ei1FxYgWb5pO/SXtF6hadcClLyPYpB+MpQNWUm+Z4QI2vMPfbBApg9Z5/yMK2v64j6XrR6jF1EmZxYItRYRCpL1qm0WLhQRN0jiukC9ep8kZCf5C27YSoimWZGkw4E3KANNOalNdulcVmjE7hpC/dVSkrjQA+DE+e0hlPACwNZUaHigAg1iENKTUnzsFCO0pimh7didoE8A/vZGojYFbMiMuQ4OzLGk3kyBqJV9PSpvNInXsVRHgZDW8OatRcNw0U8bHdQdAkIW8tawXYHRdsc1QHdEwQJpnApuDrFcL3ag24uYPM4iIpnIS/XHfoLkvHJhKnYXQ23xxyyTq2qbI/avmGCCkOYuOFKinn9nqaSrUc/X4TJedbzAVog/8mbtz+SswwzZCF4qGzqH23LdX9//9mzZwcHB8+fP+8k5ypDAtoE9SoAzTnV99Ay0DDQ6NNoicZXi5oZ10VOF7EpEvuRsCxHP2M3y7qTnG3Hc24WV+3b1KdTVKJ58LaU+7BOOCnxbFUMb1yAZapTiLgozJYGU+o+o9r0h/XbYZ9TtLqtd+Zzyc5OvEgGFcIf+E1AeX+4vbNrVeXnAzpOMzYZdEO8Qu4OMMfxgm2oo2tg+LKdvPZkEL3yOkeUx3YvGc12MmcZL+s+f3egfZO3TyJvlxAaDYJ/k8hPKZE9cf9Mgnl5tL8e0f0InP544b480F+++F8eF1f77LOcDG6uWOZ2SZaaHDkP7/TI0e+lYtE3HZUqFn03ySPJ8HnktScERsUtSwKUsnUidIvW+YI8mgzWWl0mS+iTo9g9JWDCxCMfF/+it7pHqMW3R6ZpUd02S4VxaDSXKaOi7XK8XTp60CGOEZwrQtsFcD7p4fFA/Hxhn8/D3x4RXxYiLmOTcW24mJZcz/xzuuGkg+pPlbLir22wTBloKp5teoRNQRM5Pd4mN5q8pPNxRnvkx+Nz8uPxKbmpNJyjoiCnYspF2EN/f2Vfsd+7kkJdO5EWBWHuNfvZgdxzmKpS9MiEqik1rEdymL69H/H7ZZfs310k/7vL4j+ZEI6DEr8+ERuC574J0K9GgDof+Tenx+dyejQI/s3p8ZROD0/cfzOnh0P7T+X0aOL0VTg9HNB/CqeHw+XfXcNukOHfVdGuyPBn0reXR/zr1MiXx++bzv6l6+whSE5m7ErzqaCm9KXXXbSczBi5qP1yd9jc5Yxp1qxmXoszhfizMRdULTB9PkyqP71gYsanTJsrmk+l4mY2XyXPzaieQf01P1nQfC1GmKiBlbXvTvuocWWgAzb8oNhAhWvikndDohBUzApD+o4clunhSQUFaV3mSMXPSJsK3Da/6Bnd3ttfdotjeeE6hVsBtGMpc0ZFFxF/wJ8gDJoWEEbJsVKno4NF3WVFt6NDLRt8JP4zch3wqd3nKyxHbRkiClxelhN4h7nkKsH7LhlkTkU5oa5XxHhhKeRbAdwwkUmVRGOyqnK5Yjm7oZgoe1RYvvn+zQUErHVl5MwTOydLPhSpPY4/LJamraGmXFmxuaMs467EZFuKwHnOlMF0QeZA6abxpMx9zf4plB9Si8LIqaLFjKeEKSWVrsIh41FvaM6zuJyKVFYIaePnIy8ZvWGkFFEVxYlPzIdXq1e8FlKNH4a9tbazSGcsve4qAX/69u2bt1fvXl++fXdxeXpy9fbNm8ul16jEjjMrKo9xgcPXS3150R60uqogFU+VtDxMjqUqZK1I9scVC0bnK97Hdoqn3MwwnlRut7pyxH4Lu4YjUbxp5Rx52B4+/dtP//jl4NXB0d+XpqXvyLQENbOKVWsUO7FbhIqM1DtV1U/2Rg8pKOwNZ1pbrm8Ptof9gf3vcrh9OBwc7gx+WVrOwx5jyzDHPefS+oWR9hCGpYv2ecfeJemsni/8d7vhMby4ev2u93xQeirnvt5kD0k549XxXsvk9eHGlaSxp7+UuXbtJ1y4OAExgnoBCqkWuzzsBAVJ9ol07T7wMTEOrKr60X/DFOaJ0ynlIqrrZ98ICqRV8WNPYacspjXif0TQLkOYSmsGDdfJuKAwx1/eU7Q5PFgvzOtK5raaeUW9gFz/EAdkgCJE7JvQog3D5KvI8e+8wIr09BnLiygVDVIvsKpIGFm7pA6xsLaH3etPEIOeFmVShuZd9zOWTmnOsqtJLmlnsbf1c6ZSq+Yen79DGqLRy7Xr8sF/r/rEubqncgJP2zMwKn0gMsINUdgQBLAeWJYdJuQipZApb7UxqewpMhgE/tH441X847K7K+P6OlGMZklHrdAHVYiF80vavVThCGOSjSktp2wTGlQQjeV/sCbEBp1OFZtGLcRcWhHNcwBNbxLNRcqqdHDsRxOV+F/alwmo3ipu2GfA1c5jmPgD0V1lomS17XlWj47mczpdqdMl9qjBZCHDCQGyIhY7Cnla1UEzdLoiyCqZ6uCi00YyfNSp8f7po46N9/RsbHr9YVbX/rA275zNpVo8ncB7BeMRGI8UKP3sx+UFWGD/JxNkK2S5amFFqGQXpsUK1QmbQu2DpxAsd4kUKEVlz2F7IOd5KI4NFbUmNG07Zqpd8WRSxePLxeoQDr1VPeZ/JMJO51gRa73F0cmcCjpF3Z3rCo2WkYLtTiM10GpMV9ooRuexInhiFamL6uuPdIKMRvGamaHXDAvScIGF9b1pIditazVXjR9KXut0xqIrnjPR9Ur94aqQYKhWET0aHLrQ/NMTXDbLxvrMz/hVlxQ5kXkuoSvqnArB1CEZ/XeEMFxq/k+/9pX9rJlpfAvlmwqasv8ZVcoshw6WLs856pAK9lKofTCj0A5ZeWNJOQ8NodpX/anoyMDgizDRCXklVaMrh2MVrOAzkaVwWaBch87UUB0Kgw6SVG6NczndoqLPhQm9RvtG9s2M9UNsAjW0j7P2cZX6uEq/2rcdjIXU5p9hjY8EOcW3NaMqndXWIJVCc0g+rfdOGtP0GvtPZjxlGq3PcGFQZxWoVjvXtfJIjfddbV9yUjJkDtxFN0xAZdL2uBqzkqFMEzKIHYp98KypmLYSw2BrjlpFlE7eZ9rVsAgdSkfvRz0y2rL/fG//+X/tP2v2n/9l//l/7D//n/2HjMgGsFXFJpse4lFvBBdlo7+MEt99XDPcMnWiQ8cXZoUe1PConJd3MMO05BnbYsL3LMdhtsIwW2mpFBNmy1G4nypGDesDlZKZmed/afxCC94vqJn1C6roXP8ak/CfT2CzuU25hCS2TGeoMFf3aEtrlcfa7qGowaaZoaSjhsyhQ61mQjPvhnOutffh6HkfmbteeCXvRatj7UhMufiQULAH7LoXSs6ZmbES/mIig3Lio3hkZlJkvhrnAmgQ03XLwZQ22C0Svs+wF/6M3jBPMaKZiUe9ZaGFEIrd92vgIePp+7VQQ8e/C08kZISlMty3I+cVikeFGcN1EA5MNRl1yNVR8l78wBYSHE4NRo6H7DgyUmu/KU4tkiwjcLxiYYJRgA3nnlEdbYN42JgxD98LQr4nr3yJAs8Ho/4If3ktQXdBD4ewKmkkzdea53O8xg/RXGH/PxVnH2HVE1/CPYyfgPEEH4PDx3UpoiABYV9yMY2J5U6i5L14RQVUSVea0Nza8gsf7shc4XYvjLGzJ114nyJyU23LdOkBQt76e243xphpQwpLbJ4yLEnuyJkQC048JEIGdeK8By6ucA4XLCP39ihx7SyRVZz7HLokQ9eleFx70kAznvDu3cxbP0PqvBqP6dh2FJYmZlrQZir5fQ+3xkN+IuNW3ceXZdslY8GW4dj1I0HkDVOWhCB7FwWrCSLHL3H7ADyd8gWyLsviMJq1XE71GjDfGmr+ei0hPzPCPhQsxe5d9uCnWUbWjLL7Ya3mhVvTC2FmzK7rWtXXjCoyKU2pOuKP7ITL+W2jflw1hb3x9T0Ke/RopXCiU7upIDJvS9U78AXosX3ZFpZKTuquWbgiqjqpYWGdWnO3nquxbDUU76uASGPXogs50i5o1FOddja48wvbgVvUMu5jzeLwHHbN4ip3813t0KIJQE3NoBIrapea5VzUGsFizy836tg3UgMfv6hjrO+a0JOhTky/XeJ+f2dRfSrk1TC2vx50d/T1+vUAb9ySHkpfwQEpup/zVAhYYhOIQOmvqitcrdndUq3hwrbHAZ6qNVwYFlrE4U781hruW2u4f6/WcPF29DXzQTJ+ef3hYlC/NYl7erp/axL3rUnctyZx35rEfWsS961J3Lcmcd+axH2VTeJiJfHL6BQXQfStXdwX0C6OF+Awj/jkIz3SWK05WqH4jRW8J69+2exqj1ZVTv6iOsRBS7Io8NNhCuGgFW2MtItlKXHCIDXv6TFcRc+3Bxixn6/xW23fky+o+1vN3fmtBdy3FnDfWsB9awH3rQXctxZw31rAfWsB91XftHxrAfetBdy3FnDfWsB9awH3rQXcA1rAZTmeuz7O6+VL+PP+hIxlCtmAyz3nY0UVZ5pkC0Hn6ETxBJU0Q0+a9HUD4GbD/QzhnLJgyvWkAhmpMY7cSoc1PaPQz702zxoqhVVtFzBovCEw9mkJzgJgBsfTLsY02FI+JePQQ/M9OUEE+jkX126+BdkYJVmejzZJKudzSKkAB5EU5GcuMnmrq/cvENw3WBBiY5Ro2fXeO8E/9EGZbeHegqUGxiLn464B5zR9c/EEGcm1KkjJt3JCn6+cUIP0X1F1oQbk34oNra7YUJPU32oPffG1h5pL9ucpRdTA7FtloqerTNQk7Z+tUFETv291i1ZUt6hB6G9ljO6gk9U+k3m2tyLp9epkD6d4EDx6RocrAujip6Ph4yCqVNoVwLS9t/84qPbctfdKoNobbj8GKp0xtozEfhRUFyenp+cPg2pFKkfNv+ts1eYBjEdKni/InBa6q3ICGGdQf1hftzfzNVOC5TvbiXdkLIFuQc2qHJkvyjxHiO0kLdwbwB8fvnd+gvcXYOPvbL9/FEIsgdxEw9JQiXgFdWbO35F4Gt+Q2/u0LdotFD/s7z4AC3twUrFYEQKYhANxpzBNi816Pr83I9TAUzxnfajp9qT6ccGSCLBVY9sIf34Esuc0jhH/OHJ2+KsbpvRnwM5N80jM9pOd5Pn+YJAMn+0O9x6AIp8Xq7wPOcJbkFBIrJDKuBY856e408iRIA4K0u9DoAg8RiK4iP3FXaF7O2fCxZSpQnHhqo1DztoNE4RODFNEMaSYy9/07XmsvtgHPCs9TVGhg/mvscSCTKEyR9ZzKX63GGUBmbxYW8UoWlX/sNBjanRdx1MCH6amViFkwhVjCxAUWC/GzBSjpq+YKxCyPRjubg2GW0ZhBZb+nObWaOsjcfrOmQgVQjoCMdP9g8FOusueb28P7YcspXvP93cozXb2s2zyAAbxGVFXsBlWeHUXdsKnSLOL86Oz15fJ6T9OH4Cis4NXjZeb5lPwWwvi+v2Ho1PvnIfPb4KbHY/gtfsJEO5NBBp0/t7k9QX8ec+9yQu8MXEJH3bCk9cX5LeSwQaE+kJC3zJVbQT7O9z/hPRnxmEvhiBncNuKac7CWAtSKC7hhmTKDODlhnWDbowyoaGo1CE8P9okeH4v/CTx6BBO4BPx8R7U3fiYkJyM04bcfo2xL7QWV+ZgQJv2lqETBdcuZHHAOG0o8dXR5lNketcosXSFw1YxCAp3d1EBASrcGxjyQ9OZm4torOdGFDOlEtE1tb9NaHa6uJwxAjEL12zh6FUlWfuFQfpr5mat55CPF+T0+KJyR79lqVSZGwtkNEjW2HM7r9DBH/3kgtzat06PL9zwzdwju8aW97AMBgQeQ0g9w6KhtYIP9jnP4+TIkDkXfF7Oe+7LMK5HCkpgRfyGNXRGFjgoQdBCg+sq4qVnDYowJIQSpnCgcvDMWYyoJoXUmo8xiiSDghtWL4zKm/hyczJi4xagVJO01Eb6cnDNLHaHc5rTlZUZwF4vFFMvwoL4Sn1V7TXf3waOedX23p297gTdjrYqXcdX+ItFI8ae+kD2+uZgFPac9Bl0+GrBRKZ9RA1UaAFp5UkSD+hxbx3/w0Hi/+ukwiozFpuJ30bGzYkaoJOCKYjdjWhzBm4wcEPKCTl+ffTqlECNIlcvTuY3ViuLhNP6usYaP6NIxJio6IQUDKUGhOLoQloSh+uYaBDYlwk5C7JKSOOjJptj+kzx0W8l06HCwcgeOyyq6BEtC4QQ3xE17pfGmGXiB+8tmMwh2NswdQP3WlZ0A8JAgc5V8O5ems5iyc4mIJhq1TG4TqnKWJaQX5iSvhrQHNylMxf3gTK0IuC4ohpO0VGXoJtRV9gI73JWNcF7pIwB3qzBPWM0Y+pqktPp6i4tfcDNNnFZ9VZM4swEZq71mypYamplmw7J0VGPXB73yNuTHnl71CNHJz1yfNIjJ286nMy/rr09WeuRtbdHPhbnrsrXT7o0FidMM4qvw6h2oQ1O6yiUnCo6R9YLtzqVYQepBkxhDZp4IKhbWfCqfAqKBd1hWW8Ph/U2xbLoSHp9cuRd2IwUeIGFChR2BXBXQNdcQK4P6q01VZaQOdOaTlkSB5BwDaFCjnZOgBl/LYjDoGoMlIGIpnjMO2n0t3enb/+rRqMgEz+brqCcdojnBJojH1ULaqJ7lSciHIUN0OITLziLXalMn9IipOiDi8OqgnF92w3MbdnZhronFgIy3N7fjFNFpK69UQnxOLeUasJ0Sgu7p6hmZDjwOaGabLw/OTnZrBTwH2h6TXRO9cwZer+VEqrRhJHdUAm5pGPdIylVitMpc1aDKz+b86ha0oSxLB4Bqskql8f43vTIe4VvvRfAf8zdIz7sdA3r/Ifn7X3L1fuScvUCX3zmpD1ecyo4DO/LtGsJi68ot+z29rab6N8SyVAEfkske1giWcVAn8c8cFbS/ZrF0dFRvaSSN1WvPqXmwVHLQ5fn5OzcKnIMGv+OYs/GqOFi8D+OvKfP8Q6fTHha5uBAKjXrkTFLaamDV/qGKs7MwptGMafOqdHWJIyKeSfk9IOB4sEBvqgqpAfUzJhiWOBX6CQizqjSWaEMODfBmwXhbFDq18zYHKqZREOjXoAvwe+Mag5B9WHEG65LaAzl1BWr4U6k6jRzIqeJtXeqP4dNw8frwZ/DDPBzdVfBef0GAjdr0K1wU6zHuyJ49X2QVNZzFIZKfJbx6sfWQpYqKuIe3QpA8NiU3zBtH4rvE3rwRRxjhlXww7iZ0GGUCcLWvBhYFooKAO/ld3cANSAa80vhi6IWTDn8N2SBXtd8YYfQUoYTxdlquC02E3IkMkKdhyaM2arrazfV3bcT3o9vrTgnDFr8HRy+obdvWrv3OT3+2L3PK2ZoP3ZS+xZ1zgv96a2dOy/aowAexX4ruWLxMJ/EzKfHF+HWHQ62QHfsg2FkQkYs1Yl7aIR5nB6MSiqCqgSyqNQGuybDFXfuykjGDpmfZ0zgWsLCpkrqSIPzld37fec0dRcaFiAIA875dGbyRZWlUXl6Kmzg/Sg/KGcGW6VPlbvhptm/LKi+zko6Y3PaoD+pZW51sNQwGSSDmKPySY2jXr4gP4FT6iOM1ZmH9ZKL8gM5/cDSEk3fl1xcw4cXWGdp4/Tli03ooAhl8z+Z+T5D3NErms6g2HUce+SIbKnVHXd0sN9fPvRovDDsSqpsqULDj8Hhh4VhRLPfSmiBIid3A/6SG5MzcioyTpcPuC/KqxWeX8fn78LxdS/Vz4RhS0etwYnApbiKAtMfE7/utChobMlEpQSFEkkW1HVdMT05s+KCGpcAFjYuN3F7PuVDCjK42LCKm68uOKHX6Et1wSWIilR66YhL9gEiepbAepJTY1h1c1yv0ckxGh2HYxlhOZuHtEcMPV8UbHm40B2e0DFfcfzW3+thW5ajjqJsqx8w/PvMt1IjG0c/nG0+FI1VOlFRRtcvGJv7Ylk4V3i7Cp3W8CiIgHTzPhBMJoxaxPVin6xEmyNmNcGnUtQ1pVwtD6+vDT4MsSVRuNX0AFcH/9Ig6ys65isC9eN7y1McNYg3Fw+l+AqPH8cd951Ay0L52YXaA3eai/R8qnMBh3uCc8GFMS0DmGBRxtajQqd8zFRrrcNJbe3pT4mP0uW4j9psGBK8yIJRMyMjlk8Sj3Hy/Wj5rRxeSmd8mbSTDiFZ63dR18JmvK9/K10G4piOec7NAlLbFR+XMcn0A7uIBritBJbFMgH4DwL9YkaFkIK44UlK87R0EcZBTXs00KsMG7DMd+H4EXaVixR4KIwrvChtgRjXKl4eQl9v/EpOJsv1MXwSYHG2TwBX89+XoexDmoW0gAy12O1kD4d1hWdjC1Q71MMhvOHKlDS/Wr4X0oP0uxaUbr56RbbHAPz41X8EtA9c/ak9cj/XkQmT/dFHJmL8wCPTvfQAFeOxG8VRzRMrMNODYV3xhm7A+bAtDXWGrkJFpBWB6TVMV4WpKvQEaUYQKsV1hMzS8BuWT1aYWeWHJ3oxH0uXgGS30ZIWRXDgKOW6Cnq/bfhi6dpZVES5Fq7YCVxGLCBGLWzed9gNd47bHZ9zwfxFwaCXWs7IhBlsT+mvdaBAXko1urlUHIaLHntuNMsnUR1ggaM/QabFirpbAJExsK8RLI6A122pbAUQ3F3SsQMCF0z4ETC6K9514O1jE+v73dD0+gq6hC6xZW55nqU04PyZa/NdYvWKFJpr+pbUXCPpLLcWOaR6sA+mjuRnClgIy9iLg0uw1gf4+eIUNKz6HRkswQv+L3pDk5yKafK6zPNzCUHlp/7xWIjc+JsoL0TCF/cLEbeBay1IXSoVVMz4YO4ozFQ1yQd+MoqnNWFQdc23jxJoUOQ6U+pWI9FG61ToS1k1J0fhVEV8vJRBNMF9n288HioeUhMyHiBiRkyrMUjoVy4nERJuPD8U9WV+LJdBMURisYeq7L2otasLkMbAlNBOwY3p05gghiduGICt8sIgqRTCKYljZm4ZVJKL+pfSeqdTnIwLbrDXkV2qXGqL25FfiY+TG1rW+CEh/0mU2IQmJ3NGdanAz6NDZ+s2ZaPH4LrD0GsWeDgmc8weFY3nbC4hy5BpO4wfLqso7frK3vAgkQybQ1R2qVhCLhiuuWvZbk+6EaLNMYnL3Sp7LxAUfA0JWWELx4llDlIoSmSoady9ftL1ZtrO0H+6Ro84eogD8RHmruZnpLrHjcIwIzzOehPRW+TMWDYC1qgiDWZUeHqn1LCphPAOP35YdCtIRkCoPs2yUY+M3H7qw35i8JVVkvoYzZGN4r6QUYkjYYHL80VsQLhEdnREso5YolIz1S+o1paYfUw5rS/GlAlzxbOrFVe3m+IOspvL4+HCifBeUSpfrslrHyMALeFZFZSFIQRAmdAv2XWQxabXkarGoUW2v6S5qZecqjclwn49Elq8zawOknomqJdINlUzZddcOYQ1YDRbZcW5ugCKTXLoPj5jRJYmlf6ooyaAJO/q/+DqPAEZ1td1LBy5jmH17XPmly8vvJAKIzqAU6aiZtV23LOTkEg8ZVharRJo8LiVZFzrEjtkV3e69dXxnCo85V1kn6sV5StRNat72QWsjejTt6w+hPR1u6vBooehyBUGwUBDVBc9gj3Kw7BQZeGWWwO8akuGpRcaLeQr2x0qUNeitISM1goKeTJlGcORxV2HRyHKY0bknBvDGt2dO/rWH1YPjCq0+i5iMpA4YnwkEHRIidOpiBy7jLFab1jLJVFkSjXZnGsY6COTZZJpiJsNy9KYt6J1PP+982oupm5aVwNPyPb8sQS2y+uWIHa/jOwsV36Wq7uGrsECJhyytns+3uYV3YJ2h5vj7KQtW/16LWuF+1NiNScfFl50fD6RpYIorGOc03eLxnoJGKzKQ8BGLC4w/M8Fh7s1sAN54MmMM0VVOourTjWPwcoER1GzNuZTMi6h1dYaROpUI3Km6wHqkbTPDVNO4WxMcegO0RFZOH09BLgRKHDvAsbdY9W6pobfcLNwuWihoiyojXAmhcZlbka7KCNfeMWXtqRxa1Fdjj1YTQUjjO8DI928EI4O0sBCWDAVqPF7aPGvQ497HclJaixnwdKESL2Iku1gy9qR9hF/wtOd92fOlk+jtMFQlAKltD3fIGIVai9HlIua+/viB6VmQW/PmK6VFnUWvCaliDr994hiU6qyPF59UMDhaWJNydJ+kIpY9MAHDJGIqOvLG6ZA0YeaQP5I9sY117Wjy9U+QVOzU1bs7u8e1ImPyt5HZMFd4VnrbjfgIPVz3b6zVS87iqSzMm/CVVQUUjGKdZcFijmwxsYLjEsueMFyLtidPI31v1PXN+9/h7KpKDaoib+q2uk6WGv0A2hZCDm7owN6fCoLMrdWkeamxDDSnvO0m1tJwrRuo41ZR7Aqatn+zzROC6+VdvLXqmhgZSyH/HS0TeP4bZfx6+4SGopIzXKEZYFX8WyBNQnl+jPCjZMSDUjmUnAjq0oZ1RBWO5TVitk//U22keSasYKUBeqI8FK8uepUTal23oM6Ha3ijjsupXkvXtmG5tTOZtgeDPf7g73+9s7l4OBwsHe4s5sc7D37pZ7HYM/m1g3p01dMdNM0SjyIGkUwSwkSS7G2lrX0oGyDc2nlcmrJ7Y4bbO1J09o5k8tpz7ngcjnd7MWTxwWS0ZxcuOMFa0NUoi6ulG83RQw2LDrUFZuDzIa6+VZT8zHhMLw1MWtzg7ctlJuYy6zMK9bHHkfYqcFXZM+k6VV6bjxMx2FT0HTGkogWYXlLtUzz9I4rxcabXBSluQrREVRIV1LCu+BKEz9A9Sue57zzGcxVAx4ZdjLOiZu6Fn1OIKsuTFvnJJRTSHW75/FvJjLYQJjPZ6r8uVqFkC5Z5AUNzC4y742xa8pb3ZeYWKYIwl1HSgVq6zRpHiTIb/bg9N97tSoAbs8aSL+TY/DYZXXf8wovo36iekY2CqZmtNB282kD11FVhT4Iy1P01p1kBsKPKaZ4Re73uRTaKIs+eG0hZcFqjk2mH27v7O7tPzt4Puj6dPTD8UkN9VXeoJydWGy8Vyv2ezVgPqC7k73BIKtDJqasXRh8eZ3kMpwJ2ALES1WqFL9hwaJLmTCK5q4yi5GqpWGAbuE7f4AyMKoOnFgXb/ClVxfyRaiYmDhJWZ3EuZat0WvaVDzBnLmi8772Ntr69ry2AEXnuzvLNb3tdDeeCef3srsL/a7WDNO6nFuNQUhicQNrpxc0BXf2+mSvmZJC5nJa6/hjjxp57TNsuT6s0Yr8ryZy1Td+uUdLndl7yXAwXL7k/DVvCqMvzM719RAeZeiifx1z9OxAfT9K83oICr15tSH+OQaldiGhMZndvuyuUqLUNmwhANXbdb2ZVbcF7fxM3mpBeRe37aE5U8YrMrAXahcUDfeVczRN2o7PquEDpofNsNWtxsIwAEGt6GJ0wJEZFRkkhFzO2AKSzG6tqQxNf/w2VcziDPdF1ZeoZgBBlMwrrLmBUWCnz1heYEyNNpYZbmcM3H+hNFQq5+gDItRAQt20zKkKNasq01FZ5apD5bEUrLF+TadamSKLs0TV2qCKEODS1BRdnqkzH8BAQVlVFlgC17EVNFy2JjIMjRZFXk5BE2h7UqpEVwo7QXjtGfXhI1AF4fzd7Pl9gyOPGqUcaqZgdRsMNy72+bv0zBrVvex/EN3r5H1rZTf7YIKPwHKtMFyFTfbOcfmdykHMLiE+BAt+2uf8wBuunJkuco71RLmxFlrs1CmoMnrTcnK8Wbxy3yNA5YlURDFIS7/TTLc2ATzhWoxkMr2qHNBWHFjdJyRkYZE0gqV/WVZtK2tfuGR7AMQozm68tT66wtUfwb1MqRn0GMKek/KGKcUzx6w0Si72+fQe3B4pcmYtUM0YGb1AcQXJNouC6ZEX06NTq1ryFGEkb5lTmztOsgtWkOFzMjg43N4/HA7wLvX49MXh4P/6y3B79/++YGlpFw7/Ilj5eE4FnTKF3w0T9+hw4D5USq4VdboEMYTdzrWRRcEy/wL+r1bpX4eDxP7/Icm0+et2Mky2k21dmL8Ot3e2v4uI0Qj0CEvVdca6C6Uv+pi1huRjT1mH38hX+MiYkC6/MMhwPDsjdzP1CwKBBZX1THlu9bfgWiqY8gWcwkkqDHhM7JmN9ZHxhqelzL2WxhVBc73uXL1gqN1Nww2d18Oz2r5GuYk1IxsqgD21fAuW6JyrTvEGYXr2CHS+S9QOeOUdihCMQD+yh6II8HuVnGK9DTgOC1l6y5VsBNzcPQwWrkRNJQxaFf1B5dThCF6PqjFkFR0buswEPwRqFnb0SNjpUM0BjygrR2iexwu81LLexKnpbmHjchAvSgX8VJFFuCK87owDJyIU+bV6vtYydeEmuA53KF+mJoWrnhx28IoEk0bMkOUMPyvEAIdLiEOrW4168RFDxSIob3DicKhDGq6ao9u762p1NBO641B1ZK2JGFdQelUZ3OsXofZF1z5DdzrsKlRUfH2ei4V2Pri29/2lnEbe5jmqjTUVoyq44U3UkIzsjOY4JC10KLunrqPbLHAkXyz03OqpM2OKbBM86tjprBy7UAV/D93oRRpG3MB2Jb2qH0bfodj3x1X/qLRGpJhu3tW9pbaMilG9uozNtzA6uZ0t4tIVPsysLaTajueOYBw7GtDN6kE8BaXciVZLUcfgIcqnFq8Txv0ZVDAfRgBvj+oyxQ0Z5Ie7mnKvIN1GFWjV0T9bVL3ELPIh6KvRR53csjGBrpOuIpZowBMNaXdvxgR3x47V9awQDMZMOBsa4AUxWltnBBKZcjTOJQRjaG7YqINpLqGAl2tDR0oRLvnrav9H7X7F6i7MFTCbm4C8e/uS5Fxc+9Jg9/fP9HzZ5Do/CrYrhlA3nsahcyGeFgXFUWQx94LSUytBHzkJDsE8tAe1Yni6zqWA20w4csONKNCzvSq+SwcKiLhW3hbMsfWXwQB8jUsvD9fXVzrSEe/SGie5pJ1R02+5viYwAtiHikvFsTpXUxBqJ6uIljkkUuqofOc7zdztGaAG91furg91AbtzkztgvxJSLdMd+U4k1l+DL47/zjIY9iMI9TAOU6cUroADEgPLM8PBoMN/OafcNYx2jfIXsoR1r98ouRMBJQnUE9YRQLp+gWiHuHX+SGsgUedSBDSQaq6GD2hJ2OC6cUfgy6UsQb0HpXetX/g6LJiweteRDtHqjUehkhHC72/eMDuqFQfQg2tQel2vfs4+0NQQqDTjatg7nSgKCIjDATxs1R1muAlqUeuGRWb9A26t7qEUlODFAOMwQX3/1A7M+y5sfw5VzoOxEEaMq6FHtfbwKX+v5OMrYqPcSyeduEvGsvAHdxRqGlYCApbdrNz5FFIpNNcm1rsdZ8auRhMaf3e1JHA6XsBnzCyZoV/TKJfTRMPvif89SWXGRokXvv7r6niNvflVhhDmSLspWopK7VYYpdqEK3ZL88jdeHZysRmiUWtvBPXbsTXhRhN5K8KMWMzNnu9VlbYwbioLDPC9G90oTCkg3D5FntV52lC1TCLy/feEeAn50ZtCF+Ic3xVGHIF3hlVcyh2XhXaf/i7FCgsJ3m+k1lCyG6ISHHaFA0LoaHMJGA7mui6SK0Yzr5O5w9ozenXhEx2TuAE9c1TxrLFFn6aswGI0YVJfGxMq7FO7/aUA0+/sxE2+dloqWbCto7k2TGV0vhaV66bjsWI3aOP6xy8u1zbR5CQ//XQ4n1fChNPcP9Uf7B0OBmubDTHazjT6wrxUZsbVI2MeITyw7oBqhPKt6XLcx+DHNTjpe8hSGEgYnR2kUuRbAZVRTK7uESbseusoQtLJ1QwCDGTk+EKkoG5uoeySgtLpnDq+JGkzCv0zxi46vxIUTqlzTamW6T7yKMZpmg4CxobGaF4jkyDcuIDI9humDZ967OoeniWsCoEh525ovBfgop+xwsxao+OR5C79KmcP3meLOMHP1TsVYHiSIqcpu9M+ucMuqbb8J9kn80WHhQJTbO1tPxtmLBv3J3vjQX93e3jQP3g2GfR3abp78GxAdw4m7H7rxfPDhNJamdAXlH6sTqjVI0rNlE/qC5ER3Yl8k1KgNU+1yzSL0q3AXVrvRN/wOHxabm+eLXsy39Mu3HcL9ykZsPpw4wczuNgh8Kt4ZB9QXo+lZTuG60mTRsMcUXYKMr6pVic81AproZPn2R6lu326f7DX3033Jn26vT3u7+7uTg4G45003T5YFl2j+HS6lOfz7koTJ7WMuhqLueGXT+F3zzun0NVKG95UxHfTBl9Uz99h9rxpzEx6d0jUQ7FbYU7y2mWETmiv3Oap96KrT9F78T7IyveEfA+i772wn4pyrMsxfobwSFD+8W+rkSn8CGfAWpcEXVL8cRdU4MWf//uerOYjbJvdSIGFxjuteBTILtZkbM3CenC6y9K1v0Ksvs9LhZJ8KPf98fcC+oq7YifO6owuTEC/gStYf0D5xF//NxXZllQVsqQWZdtznWTC7dx4gVOe+Qt48qqKcvj1xdmrf/pOp7pK8XWCXW8m+LI7HNxdRyMNFpzE0CWAZUjNBj7hfKii0NyFzpOkymJM+CfYa+svqYtWc8FrOSZG+aE77zX9BVi1xBrDyKEFMBwgeAfXEYZKDZZOW1mZlKrrGK5HmC+2isKXrjwfaK03VC0szxQ5NZb3E/ITUxguD92N2IcZLTVcHuauFgvKgLoSa5Wl4CDncR6oq918w3pwkwq9AbIeybhiqZFqYVX3VC0KEwdWoOxhPTLjWcZED9Iy8F8p8kXPKY49cqu46bi4W/91zT+71iNr+LTvE7BMXprM2JXmU4HJ5Bmf2gOG5lalN7NlHK2P70qEnaNJmKwKjOdTNMTcBcTdDUjieLaAhfZX814Aul5twe4AczsM6RvHgjfKPqkg3MX1MKn8ZkibCtyOW9QZ3d7bfyTpMRXqI6byEupfFLDK4e7RzwDZq2iptg7tdSuJHss09hMX09WpJeuNpnnL8kmUaxEyxkCmR8Vb51SUE5qGegG0uvS9YSKTKql5JoNhHNsCR4Xlqu/fXEBniK7OMfPEzsmSD0WawIXgY0m92kT9+6/RaincBEHpJvmkxBY7uZxO7RYHsSenihYznvqKS8HhEY8Kmb6NYDqjSm38fOQlozeMlKJy0nHfLAZfrV7xRkQ1fuVtoZqUwqWpt1cMuplcvXt9+fbdxeXpydXbN28uH7tkJZZObhesfBJH2AUOXwtbgIxLFGVNxEJYATmWqpC19JqHYmYYna9409spnnLnw3hSua3tgjP8fnfaYlJt9DDoAzf86d9++scvB68Ojv7+WNJ6h/AnKH8ndj9B8mEtHzQwBx4KdiOEwBbMMYLTsn1EbA+2h/2B/e9yuH04HBzuDJbPCWjiZ/fnUqrtPSfe+oWRPpYjlhEd+x77OEdc8vd6TZC75IXr/+z7Ess5HhwQ2QJpnVEycO0WAVoE1a4SrJohZa6r0JEbli+wUgYqICjg2irep5zNIBQ/kczdmgVePU65gTqekY7hSyP44h+R/szIGGulu0SGaEE6xTqtrcVHZPYD6dSVg/0w4woMSN90A62hZe0pSH1CZqu9X7em0ijP6KnMv8picsYqVsbA6kDdBiH+Fnr2wzBuAdG0Kgu4/xvN7VQjd1XA7V5hmowAiyjUyWVlY8K9ZRNT6d/20R7RXKRhOH8L4eH2uxRqSzbyiOMaWU/e+AEGD77gejBhAKhlEmS0DqK3BlcFpR8/TkFwZlAuQXTFbeXjmnGZ4jdR8Da09HbXVdEVUgvDrZmcsy2ae8oHTO1wVzjMpyLbydwnCmx1bD1+D7b1Cy0QzP4sr7RM4SNJO9Oeojz3omAqpZrhAVC79oXDNQ+BJHGD9mWlEssnyZ+jA5TF5GvvAmVx+Co7QQHg/87doPJJ8qV2hLKw/Um6QkWofPGdoSJYv/TuUBGoX0OHqAjcr6lLVAz2V9opKkLhC+8WFUH6pXeMsqB+qV2j4j5KSwD379w5qvbiV9Y9qgb719RBqgb4F9xFqgbnF9tJqgbl19FNqhvkL7ejVA3eL7arVA3Kr6WzVCfQX253qbjf0mc6Wr/WDlO1F7+CLlM1eL/gTlMA51febcri8IV3nIqjmg0Tq7RU4YYozNIj7EOal5m/dMwZhc+ZvKfASHBpwwX/jOoofcIPrMmGD743VCXT3zd74OcOY8JsUJFRxM7skEG/sTb9fa0H3uw1HGGtI0+8cPI3RKVKdd0R1vCE8SgwhSv07yNT4LqqGVcaB6QGlg3ovxFoW/egyJe7tfFDh5ACuJJrTtQaPQzqZiEuzpbmt3ShYYGosUvrqA3T+JBjGNLagsAN0NSm2YgFTrxrDVfOEBJWx+P15YuLnq9DTaiguZzK0qWakKMcMlkMQ0fUhVGMzsnG0cnFZi/UIXbbIozqajHCo9AbJlyh/KuEMix5zjLyf54cXR4l5BcpWHJWBWRg5bG5dAnPtVx4X5vDSBc6GsrXZfJW5JJmcb1ncIoIZqDm9tHJBVyy+VoeFdXdXZtU80MyOj58X1Aze2/kewszaNdhVxxqOWdXgUlHSIFR49swsrvTq6rR+I1SVV6o3kqwbUt9wlGzwF30phVLMRStl5oPVw9APErFHWWeE4u06xyT2M+jHl6rxldRwHjdpXrjRYysw49Iy+nKQn3OFZ9TtcA4achT/PHsZPPee9X14WAwrN/+VlHWq4YwjrXqhK59G2oPqWSe7a0IvlcnezhFe1I9o8MVzXrx09HwnmmrWNgVTLy9t3/P1HvDZfw9j5x6b7h959Q6Y2xVTHhxcXJ6eh5NvcSm5WJ1jR7O7NhV+qtXa/D0qDQXnybS3MHbe/s7Bzv1PTznc7bK69ZXZ69O0ZPtAyDi6EC0NeOdTaTyR6Oc1LwRhJTQQManQd7e3iacCppINd3Cch5gcGzNWcZpH/y88efkw8zM81/Pjl4fRYfbhKec5ugV/mfPRTX4K9eE/Gw1wo669FYVwGuGcc56tfRmbJUQ6shGqId+R0uy0nx1nPTKMlJMdi6ITA3NK+6inUl/64P93UGDhT4xaKojZioEO1EoSwrRbfXNv0It+HXjsHGHfOjTWlkXvnYwRua5OKAWybyl0NTm5a1YWZwGpobZCdZB4VaxH/SeU9PqNk8H0mduzvrCa2px4FyvsXzBtOuIyqqZb1kU7fSwqKytu1a8YJ8j1uj4/F09zshQNWWmSsPsjDVaPtCogIzzgopVhdShYQLV22GalvrX8+mDEMvowlr6GA/awOuTwu8LlkSArRrb6NtHIntOq7iFZZCzw684diBgd1O/J34gZvvJTvJ8fzBIhs92h3sPQJHPixV6xtaP0BnmkHK32FDfnJyf4k6z1rWDgvT70BEPHovbchD7S6O4e9RDA4O4OcMyFIRODCSJI8VcKQvlWi2mMmNYIb+SZooKHbKLNBZX9T0bfP+FW9f2gIqpr5umaHDNAPSYnVkPIVdOPaKmpphNuGJsgaUpxrmcbmGt575VLaxs2toeDHe3BsMt8FNwMe270LM+EqfvchUTq7O17elBun8w2El32fPt7aH9kKV07/n+DqXZzn6WTR7AID6i5Qo2wwrVirATPkWaXZwfnb2+TE7/cfoAFF2azarxctN8Cn5rQVy//3B06v1Z8PlNKOB6gSm3yxLg4TdgHS5lO4jd1mCQ1ByEUXAzKgnoJMJKRVyTNfvnWpuFh/s7B7s1QPGYvvqqVbBLVDVACYPSR4s5VOb5bM3wYbXA6NpA3su4goIKDpLNFs+F6gehFNJKq31AhZyzE7LxDjxuqqrcGWXdbVw03HGoyy/jlPuwN3ieUOeW5jco0lZ+q+VyIqN5XcjVxsXR680EbSowskNZgK4kUVqaGVYEpSKrpSLBko5LUzm/3WUvOTv3N+VM98jJ6wsSY0zIBnQi4XmWUpVp55Znc8rz6r02Yb9PGLY9SFK59D0t0B56OKsE4VzlgeKJ7+pIgdjdOH4NfGOBgDzgiISBuC1sXft08PKRn/h0Ro60LhUVKSMXTN0wRY6PHkeEUpiVpd5UBIBZyMbxJnYsbeL37uIxwEelDli2yoU8iSdy63jymHU8/uu7ix5581e/nmci7ZE37/5qNbKoWFiPHL/+6z1rHrbOJ619LlOat8q5Pvni+2m8vHm52VKaLHtYSfF3zm4fg4lUUypcvb0VYxNPpcnGm0/YzGci/VRkaX5VCr4qxbELZ5oTO6NF/d0jcG8w+mPw14ZCDtUVKK2rq60ejk47HxbDxvnCwXnZIxegupy3WPqY5nwileD0QSgKaa7AeFwCp7u8tZd8DtYeWo3N7G3ogAS6NJiiQvOMKSzuxdsZ7tuD7UF/8Kw/3CeDncPh3uHO8/8YDA4HgwdjhS2eVokW1sxdAqXh8/7gAFAaHu4ODrf3HoESlDBOr67ZYuWVgY5axYB8cQIs9wCQ2JFbqL69eNi5ECGVlupmVRvrEqsY3rAotIoRluf2gdT9VKEVlReCxNVw+HEdFUry9zktIgiuTbG3PXwsJdiHQgr20GyjRr4gDhEWMGPgum4sX6jTsQRW+3t7O8881ZftlPUI7D/RNof69tYyd5ZStKq6oCla7Ny01fvtwe7SpSkBZs0Up/lVLbr/qRnXtZXFqapy/bqsuLj7FIQmKKEKfLqImjNO4gbIsPbFjLp6+D3C4yBXdBD6AC8JplZutRBrL4Us7DB0OqOQpara1N3be/HDD8+Pn52c/vBi8Pxg8PxkuH18fPQwaREqXKxcAkbBVRNLyLjkUiizEUmJn1nVCRzvpANR8OieQE8vLsiPkrykYkqOoRqTC/pcJOSCseAtnXIzK8fgKJ3KnIrp1lRujXM53prKYTLc3dIq3cJyTluWMPBPMpV/ebmz86z/cmdvp0V/DNboP1Q+OyP+j7FcdTBdPRhNrDByNpnmckzzoOUJtvSFRwPJP8Iy/UTD1AP/JVimrepkzgWEff3uME0vLv9aqa498vKvF1SQF9bo5DqVkenas+ZLAobq0677F2OV1jB/FCp/tFl610atLeEnY/YF2KANRB+Gy5/ZnnR3uqtVi6IEYzup01NaXLdzP+QhZpXhZnN1nX90f95T1vlHJn3R4hS6+yi1cDHxUKaRVsFeUAHHwqoYVtSCIHEPaa11ASjjUybDK3H9R99BiGErf4zYZukMFMSqMaOF7Ozca3tSudtj1ddlUeQ8lOz6pFL53CxWVUnx2AvI9j2nFEYxWu+riC0imDBXaSsw7kngubyVfVfdKG0FWobZ13U3zK+X1rYqRFZE2Ne10pRusjbAUpkZOQJbgDYABLXlimu5KlofO83o7OINELutMBx1grQqVnTgdK7sMRW0UVXMb9uPgDJl8iouJlKX2FJMuSkzrBmZUwN/tK+i/pus5VKsHZL+s51kf7h7sDPokbWcmrVDsruX7A32ng8PyP/UrwFXmSX0zsoYn/bYiFqigTQ9X2cOm+LICZkqKsqc1lq3mxlbWJnKUJpGV+vH3jBt9IjlCqVvCp3RdA/vSHMplbOZe8HsbXcSRfDyKnkZ1dUeyDk8KeuZYVVGDLpXuLCGt5yDeI/kd/uCfyy1kaKfpbV1KaQ2NF/Vrlo/h+FRfDVTtmAtPLi1wpzQd6HRtChqqBxaoo4ZuRby1rVssajARFKRX87OYwMHWyhWVeBvecbyBR5k3iaCpj/wsU2757uD3aU9popNrRKyQmH1Fma4T1b1/3bcBdOKpJWDp1NY/a1kY1bnue6Wbk9zZLrOjuR31xYsZrJe0FTOjl4fRc91Au4Ooq0jNYUjl279UDIh9dURV+wjLXHbGUlevwtf3N+3CNOMnJpnpVFH90J4RldNCRo1DZ+2RVEm55SvLE02VhBC4Dr8hYSAJqFz5nqLxt3ba+2WBXl5cnRu9/8RNoGvimEi/HE6XEiQWVV0jfOf8ro7r0JKYoYMZsdsha4Un+vYjGkOACXf1XOZYr79yf99j2HiWzp4tq04NWo9ys0t1+654MOMW5DiidoI7YQmfsGbqbyjzo7CXHcY8upkrwcJaZsES/IwpxIk5CjLPFCT0AgGw1PdEOMFyeUtuJR9YH4dRDzxqfewYh0FbBysWUEVlCd0I9P66bWhBb3Gnmo9gs2RZ3Tnam+4vRkQrHK+q3NOMxPSk9tIw8NRWeoSOvPcBLOXEgWhs1bPYQL6zWKwIDkFFaMfrEQ3oJeN/6I7LigYKRCkMvSYy6rELgQRsnvDLeXCmZpkw+ToqS9YjyhmJ8N615tPYAR+7jTKz59B+cckT/4xeZNfSMpkEH3SVSz3os//fW+rLehr1Wy1hTfXudufVmxwoQ0VUbvj0+MLeDf53kuozi60Vl9ut6aCSaWotp/XYaAV1YwWBRMsAx8bqLpVMMGcUV0qrEV3SzU0kRQJ4OrCIuspSDOqsluqWC/U1pljBWHdIycyvcboCkO5ABPIbvz/LMeQzg9dkLNQmPFT9v3dyUpPojxWId2ujkQ8X1c15Kv9esR0WpRJqel0mSMb+slnV3d3qT9nypqUkD4FZwCuHkS0hMbv7h62artun4bu8TXLhxs8DVzvbWxdH6lRFynNLd4TarUlS6FaX/tIyzqEPygxtxLmAR7sxbe6Ff9Cp50bpujUKxqVme1e173QjXwAkA6D8aURpqsYpmVNsIzr60QxmiVxxu5jr/SNNNUFuM8CJhtTWk7ZJnTqsodnyrSelNYw36DTqWLTqLsAQbrTPAfQ9KarcB/KsmDPOJLKPH9gxT1AFXuDrR5XO49h4o9E9/PZIWgxyEkkNr2U98bIXZZIVU0ed0Yabwk7yPq6vstGCSNKRV4z88PZm4ua9QIzYaXY9tgV0NFMYUSwjlzyi+ooUv/m9eWbizfLLsWUyeQLcscDOH8Wl3wdmS/ULY9AfnGu+RisL8Q9b0H64l30Fshvbvov001v1+abq/7JXfWWrF+iuz6C68tw2VuA/vxu+7oTYEWUX//JjR1radGmOjPOwKtyCjW5nTmpOPKQjcAfaPeKYqZUQnt/Muiozjr/iKv7afBxfm7UjeMGYkc60BHNVuOLJJbwSs/KRt9nPVxjzBkVXEwnZW6l5kKWijBxw5WEckrR8Kd+yV2EvcKYc2dtjsaMGqy416RC8REq8KILT/CN8KKZpBl8kjRdFbOQV0fH8bSBAhZxIY2r2Y61q0BQvn1xTJ4Ndreh93E5nUKt4kNyStMZkalhhmy4NmY9ctAf8yqx2tp7m9jt0mm2zstwK8mvIer6n2TGPtCMpXxOc2wCqMmU33jfOaxpZcggn+PEFJq5lcK1ZObCsClTCblAk5LfuAfx2sv51l1n3jDibFHMWMfhuf7r2mDQHwz6e6fw705/e2etR1pf7voG2XffszzN8r2+d59D/JZLG4YdHu3uaFe/E/yDc0l5vQUM799KmkMpqjBmZCeC14+iBuRc/ZW/qNSW5JCuYJU7RexSZtCvyZq69eUz0j7f2ESudX/CplAT/ClcD3c5HeAKSZbg6aR57qcG1oEmKq1O3iCKnszl0EC1oOk1W6pE+HLIuvG+OHS5WN3SKpYyCCX0SH8huK56bQPefxC+UicTOuf5qsLN31wQHJ9seJ1NsWxGTY9kbMyp6JGJYmyssx65RQdZuwAGPtmCu8zzp4P6M5chad0soISuV4ILFamcb6nb9UVTS+VX8l/0prW210wJ9oRUuh8HnC2ADYadoreuUUML8t1kNxn0h8PtvruPbkL/tL6HL2OF44qMjlB3Lek/mvTwESGfaz39fG7vpkwYqXukHJfClPftV6pueWu/rrCmzvo7jdJw5OYZOW8D9Kc2bCoV/x2fkE0kuTCyUkwrY3OsJM3ApGIKKrCCHOON4kr+cc3IROa5vLUjOwOmXlSVbPh4ErZ5SHIsPj+nKVBU8A9VTuRtq+3sGYL05sJaP+vr0NMD7+fAGeNMKReHkXO8f2P19uP2iXGlw4Wr5ISc54xqKCRJSg1OGXvWyIL5PiWQ4olTnR5f9CxVCyULqRnhJvKJucL1bS0c0HzAkbTain8tPl9WYA0HyXA3GdagbXP109gJl663XsNGeCEVOc5lmYVbG3+hhBkZcJXvWvlCRaKcXzMyMtvJnGW8nI8Sy0w384rb2ldG4d6+h61pwh2Wr+AXZ4JUxnkYsctIr9sKZbFkRd67lKoLlkqR6UohmlFNxowJglFr9WXb2d6LwzmMqUVg/nR5eQ5/3x3O8cLHr4WkGfsSduyH/OYgf0qVe9mjmQlNJDxS1tJSuRcxiv1WMv0EsZh+oLHMFo9Rzz/aW+siri7XAJ/ArE2iHxw8uxtEVz15CSB9Waw/5gy/dJY1Lve9+P7E8lySW6lcs4cW3itYlUu4mtf3rc2GBRYc6NjzsuO0Hu7udC/VyuJg14+cv68ZCgtdsGq0Bse+ciGEuZxqHx0S1jLNOTQQsThqKAcF5U2hpCj1baHC03ZFeVaFSaKkw+sYIqToa0NFRlWGYCDRKn/z6B/9twhZ/+ykahQilf3l2AHKpbC/dlRU3N5hu3v7z/rs4Pm4P9zOdvp0d2+/v7u9vz/cHT7bfUBAi1+kOTMzubKFqq0FTnVfN3zFwHPFjT2PICo29HIJfXkx/LweHTH68fRyVB1JoykzvivKj+xyBI4/ax03i9t4Tat+x9Qm/Pmbi8tu6q24ucD6K+7KCga10u7HpvyPKBqipuYlhPLli3rg35hq9Bb4kzpqGBcLqIqaVvFzz4+O8YX+JejIrg0uOZbzgipvdc5jkGkY1Kp/kdIQZltf1yQe1o3qFZIZywvnuc+YYanrCaEYNZqE0GtC5lynUkz4FLpPuU3dXkk+p1O2NeVLF9D1NFZswpRaWQ7wWzd8xYrx1mnJXF9bY5zLaVwPbKsBuy6k0Oyzn+s47bIHewzk13qy34fx3Ue7x/xzn+0O2scd7g7oP1r0OTCeTvZFS/iEws+N2iH98JfHiL+arAujOuXlSWSeI6421JS6I4rh01us1vcNTtQdzLA7qMdEr9a4B7jucqwNwXivGiE5H3tsDZ7Vvrw/Jy8MEOfl+RpniqVSWcUSLhKwpi9+rM9LauY0FOhWzDWHHy+wTSyyhktrmnDFbmme94iSJbT+yCW1myOnImVqM4xabZMPYZuEsWZUZOBBouHOIZVCuOsDQs7c61TbreDGpMQqdXk0TEUCBM6PpZnQUsGtBtEFFdDicBP3dAyHv2jpIEVH2sOnW8o053RVtaYD6+AseNdRrWSV2tfrCAbzq1p5USzLzn2bI9RxgcQcdOAekaVxHxTJ5r9b6wgi0aolEXTe5cZyLy4rTVZmBlb0OjtpEqvG9hW1Ll6/Om/tH0LOTjpOvqVNqRWGOJ7Fa8Hu5oh2SyYz+wj8VaGHaSy/Xro/78lNOmmlDYFNZk+yXE6ncEKxdEYF13PLXP5LMKkt9FGNGDDKq1QlKwCr1fpoulJrOjeul6GpNRMgtHXLqtV+/iiNuW5H6oXO5TRMNGbRkQb5mWRkwcXHku9HNUT8W1VnNOn8mJA85XrE1jG06oVFgmXx+N8HW3ZcGqKoc5qSEcL8/QjSKYXzpp4eXzjyPUFCVOj/uSqtrtXCyhIcGgCA1YO0Si2zW9O/caMZNux9Pa6W6m1Vbf1JxQ3klmqxvm4wAwczTgJ8PZJJWK/QVfU+j8HWDVVbuZxuTUoBnUB04jfaEhIl7m7zpLcCb7wXxWIV4qH9MtQLOAXaOM6VMaXc7YF2BHJDKTC1oFE+u2EKAppNo+QsnN7C5SZPJSQGItvDIHjBAPvGzZtJhquCG2th364U9IUswRtXlCbebWGvW6nkgSHQ+xAVjQvc6v6nzTh3Tc6ZX0kUSaNbqsSoR0ZMKfs/HP6pdA2ad3jrmFLOPxGJ2mnTg/Bk0a5xAChO5E56exa6Vo6om/kyuaUuQQjFGyseJc2p9gFcXHDDXYpgNQPoDs5SoSQttZHz7igDqaa+3wT2R0rGUhptFC2SH/ynGrHQ4QcdvJKcN4OEHxxCY4eI4mhqjRgpF95+czwH4RKIuXM8xrlojf3SQHV3+048VpkM0eSBp8IufN9VUcBfHYdiIq7/e02yY1wguOFTg+9Vk3W/YscFmVD1o25vsMA3yb/oDe0keinSFRaPbJHcTWd3BTq7W1T+CO9wXwgypLKDmFoCfuwdfxeUTtrNmaGQsxLLcpemEp2BKD3n3MRsccOpGybc+GvGyNsXx5rs7W7vWqR3hvu7SQf8yYSmPOdmkazClbAeYegqPxM/Yet4A2zpDeU5HeexInCUWnsbdoqMsLJ2t0XrjoxkKnzAcZV2HIa0727vtBl3e+deGq1QSkSUsid1Hz1iSxOrgQekMD3rwqVQXKrlitA+bKkby+znaTP0I5eYVUNyTQ7I9xVx/iMoC0kYEY7SUMjcvq+gTwNhHwqWurt+H5BNHfc08tOfDztu+nb2usgaAHj4NvrojglK0tI7pqY6u6MFCtRDY8NIYMTaYlW5pzlxJWmASk1n1dnJxWYvVgytZtcC3u3MqbSEd/aS/3GU3Au61TPhMPN6pgVWGy5SE6mzVt+0Go8sUPHLK7hTWaBN3tAtO0FpLXmnTAgLvmrN4Y9mhjBhPVNgKSYA/+QdHBDZFX/g4kdQtNb91JkJjQjy2CfzOvrqI+WyQvx3rXAMOnLn81I4IwAtcHnDlNNQaFWlBsIR/Dhx4Rddc3f4SPfHlJnxo/sAKDdsM0mUCqcmPUGhl8oAWtU2gk76Ua3kaErsgqhueAqabYhacU6GeMmRl7wjPdBuA/l0K2PakLNz3QOHuO7FFeo1mGO3XPlWF5uNKD1U2Z2+jVwRAWm3UgXneig5EMaoucraMRkVWrq2yBE2Y+ZjOiodqSLYLRtXVLKkHME196hjpJ6LS5zQlI2lvB7FoQAjc2tVVzVqhJog+tEN4ZjFlW+MDBXbMOv4t5KpBRfT9p6lfF7jro4L3JZd/5DL23W8vcVbW2xuzJRCR/9Y2i0FJT4asUlnEzJCNsEb5RFGwFiWscaHtf3998olT/fIyO9j9xNqMbyipi7nHYfV/kGNAE64mMXVKoO+fCdq70oVkPXvkbPbAgvE4c6gmtyyPHfyL+BTKGlkKvMqjb4uGqM2QsRImffpVEht7KHoQ7uM9Lxeyf9JXg+57u4cHfVCsQyS8+nMbAXi9XkGRfQ69MHD2Zv/0K93f/qPVz/uvfqvrYPZmfrH+W/p7i9/+33w19pSBNZYgZ9p7cQP7hUDvzWNopMJT5P34q3vHMNCeBVV7PC9IO8Dcd6T7/3F5ntByPfuZhM/czGWpcjwD1ma6C/uOjG7lz74v+KRyfekFMDc78V7AUJ5TovCCh4QU9o7du2B5wyguRTcSOVLrrAPphcP2eHxrQLToCSOJlBhw1LlhrPbnqvpGDJXNXm/5hFei4eWirxfc9ivJffC60ktFSmY4nNmmGrBH4/tUbkf/hrgzWUNE9Xo0YkcLtNaj7xfC4sGf4VFW3PY+mWLCJG8F5V7qfaKczClSmqYNUBEYApoGo+hflyjGyqGFHqFYe2NhgLkjTBzK2EJNagc7tI7TJKg14vmWtaGRTArTMLktRndpuiYy+emx4P60fzFSATEZRVjH0XUu8yQSZnDt2cX5/YAj4f8+/nrcKKGeP9kre11AlrWxMhEqluqMpZdfUp2e9W6GO9gIidk9JO7FSiU/NCOnho+306GyTCpe1U5FXS1XTmgNMS5Pyxeo42/4QX57e1tYmFIpJpuUa35FPIU9JY/XvoIXPuL5MPMzPPNyhy5cMcKKCG5a3Li39Ju8WnOp8IdaKAbv2bmRS5vMWwZPrnsgjAuRDujdl+69IIunNqt8eqEFmIpEt/tf3wdUmIFU/FFL80ydwK7xB/L+V4ducmpcA/HzuJqb0H8jGBqbvns7y+PXiOH/dbnov8bfmEoXg9zTVzpgYQc5VbJi+rKITz+7tBOm/AMyAqf3SUjwB7B1LjHtbpEGBLg0Exk7tIbZAAsGgQp2p17MNhOhr8RJlJa6DJ3IRpGRmIeI2AalvAvjF33yM9cMT2j6jrZDAT/WBCGRSBx2K1oxwDN26EYtXCd1u5eOsoiwmCFzpA3zrJHZO4KurgTnQeGxqwQEagTMeU3TLhkPCwoDRlFznSo6lj5TddE50eI3P6ZT3gN7M6k9vsMni7jxmeyP8a8ce92GDjVLx0mjv8xDOmNnW4jZ7sed+hF8gr06nUXLffm4v9n7+2b28iRPOH/71MgtBcnux+yROrNliIm7mhJbitGlmVR7u7t0QYFVoEkRkWADaAksTf2uz+BxEuhWCWZIllu2c25vRlZIoHMBJDITGT+8hR95AlJjaV2H1bVdYJwwhmeEuEJiqo9dPCebxroJmHyBkIDN1KO6nOKfV2cT7t2b/B1SKxrj6YHXMgNggakzVAmFcFJYKz+08wTnjoPJZPnBqUg21dZMmkgFU8aiE7u9ps0Hk8aiKg4el2X/FQ8I76aKkPn2Gv2yjb7LNIS2DVyCBqvTiSJG2hCxyCWuoSipy5I5Xu+wn6Ey8u/sNtR4NM2Tv0p/N1T4OZBcuYswjlEA7EHMmno2yoz0XcuKsK4CQHvJu8MrUisGm58k6BisgC/OmKzaEFb71tfMQYfRRZ72/maZ5/54jDNzaCYxcRAJllWwenzhcalDH7FkcjY/AJAkg+Uni5ywGWzGOvu3UQ2ILaq/SvwlilTIpM2vGwu2q2JAH5hXAcM5UzRPLxgBza2qR02JCmYEfIMUi7B9i4NraXaufjoixb+V648/P4MXhZwmj7xsGB1uEuOpgOEma/hAKkbPqXfF9LlhJq9IXO7+wl5Axd2VJPhIWgcoY9EAkTcHxnJzMDo5OoMIPqha7n0kcaJ4IBIlod2/DC+04cgJt6RVyo6eUCi3MlRdwWvISTMmV/Mq3Nn3YJYoRE3blSefw8R+iCZ3HjQWjyAZOIvDK0VzYYADMZwCMVNEhodTF3xgws0ItQ1pQRYjAsRMD+uq7mddalmigrcuxWUFmhHeba0AAX4HiEYiCVkXuVvwb68QKJ1KcGz/aWSDH/42oISx99nsUGJoe/ZjAtZ+M6tuRJTZTje1UUkrBZ2iLzulcCHyJ7g7jEdDGUX+QsgFgRyG4t3he2RdWofFRroxEba8zvo+OPvDfThsoHOyFB/Qjt6swK9yPopjXtmmPmbs6+bGqybGqybGqybGqybGqybGqybGqybGqybGsyHwzDT06Bo5+aPgiuMZDh/v/ZQhg8sfK+xDIduvQ5mLIOLUBLiDx/NKLP8vYczHEffczyjwMMPE9BwXH3DiAZlMR+HST+LRTRypAhsRp25Lay2KkUzIIrhB/1KNOP44+9zS3KxBMA8wS+HHqu+xWvqdFNoclOmwEtq3fRmZm+ssOnN6vzioxxd4Mm1dLn78EFYHgtQYJKhFA9vPJdaWwRbC3Jsc7NhkGfv+VdO//Ko5xpDMoWH8NK+LENcDDGjf866hKcDxHgImAB5zoQkJAmh1y1dKRkoRMYTVeHItXuQNtv9ubAQ67Yc9g8vo2nDui3Hui3Hui3Hui3Hui3H99KWYyJ4ksXz4BAvGsizMzxi0MyQKLctsrvHByCC4rTeChgXGLOT2bBX0XSvrX3JqIj9m7tNI2JeKCADb+zqiYvmvLDtQdFEEPeU4ipr8pGmEyKjKrQvV/skQkx5Z/QB9Fci4X8m8D9ggMEPPE0JAISZ6Jz+KU9yq6j9LwSncnxblvA6UMJ+gYHn23Dd6RgzNRPerjy/KyHNb7Xg7syxnOIRkQrqF+C7Ltt09vdf7b9iUwGDCiJBjLPtCqV865rCrE7HjTGDXrAC4VihbOLu+OWACWivXr3YuTj1qtAU4Ht4TCzEFDmzBYdVw34j3LX7ROH2vFo+TjOpiKgzjFR4j7fTPZe8TNRlPX+5PHPEacE7UdutswzN9e6Sq9AxWUy48MA7yaPFdSw8jI+gu60+r/m+hVoefAslwimOyw7VbdYnTWMZzG2yBM57XXdsMAXCg4EBjbKxQgOr8WrAhfFymoowzFRZIyLIyVbZpMJqt6iL8/LsNOK3OsFuPquaMPCfq9awPoZI1ZzwpBkn8f3cZqfnp0Y/xfVam58XW5Q9LxM10h7eou7EG8vLVJzqYyMYAXQZxsc4gbBFyrNkwDOWiGl5x+VfeZq/R4+Zv+Bnfv8V7KNwHFc6QJjQegIsRuNUBW+yOSBRzMcTzFy0jAubuVKwNmeyPUIwJOkR/EcknQBMFBYCM2MsDGiqhQrjQDc3FxykLCEP4JQx+KALMHoycn5Wge1c2/PUl8pmXGpmSaLSZbE6cr51ECjcaS58lzu6hU3svdJufvc83Rbik8Pz9siB1Zt2NuaxvDH6XcaM1wHjrwSMv+No8fetJVYcKv6O48TrIPE6SDxXhfRLjxCHEBh4SMKb/iL41ZMXfG4tPn6/g3UoFU5TkvhCXzero+9UuREkAu0JWWqlodzX8gxRo4iCa0XSP8NRIRfZD20JMWPamtt8LEg0hS4vcWDmLRUSE/GIKhKrTNSlNOxaFaYqrfrD2/3efhF9oJ/RNKk5XrfZsWepcjVBPWkqZqM1frvkx9ztFv+bAB/EY0JpLUcV6n7omAoDZgrhCQDLuSEqACAHu4M35O1Bkuy3+62Dt2/77W1CWq1W/+Dtwf7+2/03b9qtOJn34McjEt/KrK677cgOXxKW4xA8ljsiDJRq1ZW8/7a/s32Q4IO3BztkZ7d1cBC/Sd7iZC/uH8QHu8XnmWDymjg6LlaGAH5aUTt4yj9NCPOQzIIPBR7Du0mK2TCDqCS3W0pCcuyWICnF/ZRskcGAxjSvekc55kDRszTi7MmY13bPn7IEloYN0YjfhwxDywK/orbaL5NENKEcpYGGKe/jtCQX8+sqRsg8nnKCVaXZd6UVImCAVdJXlFxKY8JkbbbRmRneNpfKY6YhZe6wB3pCm1RYGw9C2bsCZGosDDNi6OwLPkbdi+PfkJvujEqlRSBCm0NK2k9JDqEnJ8kDwOfZIeXW67Ke6UxwPCJ+4O2oVaN/UHlFBFPkO4cXDfP6+mVdYDUykiysGy1tqLD3VCbFFmz9rSOSplhsDflWO2pvRwez/YEBfb22gP0HPtYkmyiYnyx8IvGWDdivVOamiu9Wip5oQOFhdbnWZXozzXvfaINnDq6f1ZzC7ZhC093yPbK9vdP+Zs6RC02XbQFIfLT+gbNDwy1merJNJ6ThOtCpES5+xDxq5U8QEJfwYDSHSEzGDZRMbocN1BfkvoGY/sWQjBuIZfDrf2NRPvNiMvcLTb2WmFvQ4ixhN9jt6CB0Cor+wAn6AL18F/EIfjV+ILrgQumtj04eSJyZH19dnLz2rXy+C3P76OJLYRqksBgS5cPE0OWpZH7v785tPRbC97UUkjAo+oRpChkUpjWgBddNEFbwKZoS6PpXDuzQWHCt9dARFxMuilBWX2GzfqvSs5qUzctncnqBw+rsr3Cmx67ZrfKszfhNz2RrP9qJDvZbraj9Zre9Ny9/dDwZYVlbU80cGh+cmzEg4Bts+4sT24OtwxwVqNmEBqLwMRTQhfRfbM65S1wYUDYkYiIoU6hPGeBtw8M0wgNFBLSp1uLyfS5MU9KYJ6QZtrFEFujTubMSjTAUKcSZENpqN8apgSGMR/B2Buj5SmDvDgP1JsL2Vaj9+/v7aEAFIVMCePv9lA+31EgQrJqCmCaEW9ut9u5Wq72lBI5vKRs2xzjV9kjTCKepJ6RsGI3UOC1fVK14/21rJ94lB9vbbf1DEuO9g/0djJOd/SSZu9+666PRg2NQd0mcFuQyGqx70Tk9v4pOfjuZl796kyk9U1UZlc9kbsPr5+uHzom7heHn2Ye8jae5D3iPXYWyMwyCXz39pD1XpNBNUf0grY+zf5SGHozQCcCizhV7x0PPHTccoslWsBWDbrhjA3gXmcqpGzf9hCY3iA8UYUgqPJUuJm2mQlRJkg4QZn51NVcTatSM/qDxx11/AnjsMuTmceXl7JxhXRXKmx0h8NTitoPwsBhmAAjf0MIQysfrIWOpL3maKeL6IOcqckQQ8YZeoOI+4qlWyiaTwEhsIri2pqAQnCp6Vyg3r6zpAr+wT9mWlKONBtpopvq/M0mE/t92K9L/r70/W9Sl5dYDIInnOUwzkQjChspfUW7P6LEhVWI665kUCqCCLgcOKta2wdAc63/1s/iWKIQZTqeSSsQZGvF7P+RYm21+TdC99qe9UlDcrFFwlNBHuE38F8ZG/pj5EakNRxlDQmZyQmPKM+l7WpWX4BnmbEJ6kg4Zhrh0QodEqh5Oh1xQNaorRgo5NPbCQ34ybwhoegprN7NgBu1XL5hpnDbMqBwhz4VtAIF9e1dbueiL6qBJth/SVWhrVQ6fFADqbFVU3jfOyCYntyx1OcLbe/sLip48UPlVoPM+5ynBrEqm78yfwja3dIBwLpawN0HpyGp1trkg5fonyoY19mPS2yWIAs67T6j0H3VNlGY7kenjmg0wuIqmZDUPFJns+LADJ8lbEQuSkjvbhaUz0bvqp09dQMMo74uYjyM9J4keJnEEOfyLilphldV3tXztNSjoAIcMKdUidxo05aYrRiymE8WHAk9GNDbdymV+R4Wj3uGUJiGulHbbRSaVm0+b4HcEZSwH6LU9hd1X86+45OJ8fD/sPZYoY/AURCp66p9cXn667H05v7r80r06Oe5dfvp0teiSZQAHUxdsUNcMX7BEIXPHqLKVBgVmOFMEj2s+9HqKVZ58GA+e36A+BV4h8ydvY9RH+UHPr+DnHfiTzx9++/3tx7edXxYVrb6hFB5P5hDuY49Dx/o8YZaYZ3PfE8lvDnMp6INgHvT1UYIWP3Bblq+I7dZ2u9nS/3fV3j5stw53Wr8vemXA+Zzr6euJG2+zq7hrLhnqiIpzr918OgOURhPjY+Vff+x7zibT/hxcHCQx0EtqRHM7opAGA7BIBRhxbWZwnrqGXNp0I+nUvEYbA8QouLI5vczdDEpxSTFXWxaQr0yHVOG0aGOYp229mYaYMqkKLgfEdaamX1yh5X+lWseFtfiKzn6unMZjzJJeSufCbLmnaRJjr8JWkt5XlPL7LE0dVUhTZTYKuAu2mb9VdrM5m87H85NaX2/GxzNbFqdp7mwE8ofaxJIXsoQXGLqAqAk9MAXynt+8y0TSQfQNXg0+4nikRV54ObDq4OTs/SOvBm/3m/M/HGhO+lNFelwktdXRvptqy4z8kcHrJx88TvwZVSol6IQlFM9tAGge4knWq/EZ8ejiS6Ea91EGTpnyEd/5CBcEtmovuDAXuVdPHpQw9TYm88JlG/g2l5rcTZk/m7l8EuuY5kaFApXWz2iqTMI1hAuTCLLtMPM4nQN8ay4QGzI2rSR43stiLv7JA8Tq5+B8kGKlCCNJFftntrjZDEcSRAzGnanJM9cilDs/h7YRvF5GuF93heovxRcZvbvCblfvzPWU47m96rw7fb0IK4DAWBMT5q3XgDw+dk6eQ6vepTWReowVRuYtOSDUzrsAqYQpMQ3RmFeWUmGFmk+wCskaKNC6szg3Wg/tDXC4fZt0R3RuTz6LbNnDfVoTuV8/b07yZ5RlD+hTdxHJ13hF2Z3y1C31HEq/ucJb4PTZd95V3R1muBXdHa7H5BzEMRJ4naVGYfA44J6/bE2COcAGpg3HI9fQsrzuQfyB6IWyfl5enGFDr/apCgBz9dAGB8Qhh/SnSGb95kwzWkipZERb9Tchx9FPN8873v6L8YhuL6ZACzAwM4nPtCn/yGwkpY/7NKVqCiF6QftZKDZLx0LLDFcAn8yTgfMs8rsjzBhnyA6PYpzGtl1ubtotRfggxbU9C+qN2LV7E04ZTLYYnTVmBZTIDOsLn0elQ/7v8cFAkrpe/EsEm9mWJHnxlFBI9JyLUN8ZISy4eR69Nd6hJXL1UItReUeFynDas/irq7YLS5Ta+Rze63JE15Ec/CjFC+yEIYSDvtHVCpP91Ver4XiBq9V+8RnmyKIHx0rOCcxvqoXorfmQz9D6/GM+woIkvZT2BSQE1kSqs0zNdMhPZ56RIEWAyoChZ/GgSDqoMSfTDY/kdNznNnVRH6vneyVsqWok1zMkiFUj+HrVY1J7v9naa27vXLXeHrb2Dnd2o7d7O/M/KBnUlBqfHx9HGql6cyQzzR6MFjMvkdBmF15E+gHMi6mSMw3EZQgM6EflA3QPoNKF+m4o0IE+S46QZv5+9+XL6XEDdadyzJlL/kM/fzk9lnndN/QJdkm8MHMGrKZT/1Zqeqf5prLwTFrm+ogzqUQWwysatjl16dQOF0oOULJjPtZUTQSOFY2hFHBMFR2Gz/IXp8dIkEwCXP89SVMo+w0ecbGTZux3GAeERTomDYRjwaWcBbdBrs2Jlh6XquKNLd6Od/f2koPBwcHOm725S0nzx5XV7cJvjBzRmUkQLB7eIEFwRmLh886MTGhVs7/npfBdwcsVVea1upjJl7cFg22liBi7poyAYhZVNYjPjQXcN7YCjOnRO/PJ3Cm3iGhQjRhm1ur/wKNcRQlhe+fNvFtHH8BonOzVpL4+Hu+ZKcqTypHHWFz1rN0PnfYT0+bJcTVMvL23/8TUe+154h0LTr3X3n50apkQMk8Wx0JTd49PTi6CqefYd981zM2mu9JM2MB/v8vHBFJmUGxL7U3tuc2KEkjSMU2rCgBntdcEC61C1gncz0vgnqcyI5fsOsX7W6Z4W8GvM73/skzv6hX4jhK+qxlY533Xl/f9iMTX6d8vPv37kZX7cbLAqxlcJ4OvLhn8EQn/aDnhj7C5Tg2vKTW8Wt7rDPGviWudKP4dJIrb1fpx8sUDhr73tPGAle8yezyk/2+cRB6I4aXmkgck/iAp5WWOXnxmeZnkl55gXqb4e8gzL1P9PaWbV1D/nWadlzl54cnnZYJfeg56QPFLTUUPSFxnpC8qse8tMb2Khe8pP72K/hecpl5F7ovNVq8i9vtIWn+S8pebu15F9otNYa8i9nvJZH+K9peb0F6gep3XvpjEvof09iqyX3CWe0jud57sHrDy3eS8O5q/n9R3T/E6A36dAf8XZ8C7vfhSE+HryXV/jmDW2fDzS+ubJsU/k6xvlzb/fMK+YWL984n7hqn3zyXupSXnW+JeYI7+N0rDn19GE/It3vnr7iaTM/M36SuTM/zjdpjJefzRe83knK67zqy7zsyzT374/jOe079jJ5qyHIZzhSeeFQ0+zb1qyy80aQkq6mzir/Ps+kSPr73o5xpik1nqS8n6z+va6NvdlNZgd3t3+5nEgds1h3CfFbOyWaT1Ra1AQSXR6rfFFQyMTo9XIVtLZY36yZIbvih6gs3szdZziabqZcdfvN8AlM5EJvQOhN83TEjOOBK+Xg9Lv0dBZugoyG30pXuHfshB0H8co77g95IIJIkCbUaVJcJFge5J37SPhduaqXSK+ISwIIt83lXIJpry5+3uouNIYs6SogobYa3GCEPZpLRb2jvbzzXY7rnQxkAvoYLEiosVuh2r3zV6c1iCkSd4tvR3VihbIz4mWzilMZlbNj+GR/n3cSV/aB/yb+A8rr1GtPYan94gP7y7+Lf3E1+ig+iJ+/bun5v6JTl33nz7C123GRpegmPmSXqBbtcTJ+/H8cmcVP46j8tR8NL9qfm3wwqcLUedIEMqlZWF7Ud9Gf7u8YbU74FdZBpIg71lLxs/gN4Jxl2w5Bj2F2vXDAWWYXbyyi3RT65QCmZB94IqRWwb7D6WZH8XERbzRBtV+RF8z4VnXJQZbyCZxSN9CrtE/aLNv5MHKFy5JMPPGRFT+7tGEYwAWl3LidnxPE/HgmI0k6J1k056+nc3kUfQ4BNrbPYz5UyGAFmJKGf13hHhKiwAOSLPZvV1+1oPXJ783Ht3et65/E/DOUmcBVuyJ3///C7rHLU6v3x+d9XpdDrwb/Off8xrZ8ASmxvoa5BLMxX8xYU8MrAEpmpXL6M+KGZcVy/khXLhGcYSYZcsXPVNkL9dC7fQESy/pGwYpHHZz/vNAFOiV1qY3d8bINST3y4658e97u+vzbqHyT6eBqpy54YzYse1U9o6cMh6sxPCRtWjf/xydnUKc8HYbrg0Rf2cyjssKFRkpgDTZoZl2ZgIGgOv+c7VYx7/+uny2Gzck597n/W/CqQHuyzYRB4/KCExHeMUCWLzpY3P9YpEQ3Sz0d64qUhN2vzXxtHhtVD4WpCkp9Tkuk/Z9XiKJ5OIPJBnwNrBxipnF68G1UdhlmCRFNfbXKNWWzicDDnLodkS83Ixond1MNDp9wW5o7Be4Hi4KJeer3SNfPjn2cd5Cb4l0xro/UDvSBNuHXpnswT5AFLzS8R2P72/+rVzeXKdO0VOVZ9fXR8Zi8UWPl6fjrUZ856mBJ1AmqHeoJ9gUnl9T5kmVO+7ub0mrEY1sA/IInrsEDhEL1VDDwcnFHR01cJdLy0Qf8wrBHN9TPrZcBhUxn1FQiGdqxTReeA+G3BCe5eXNsh8FOfGEmi1oq2U/+pxU2kzwLeUROmrekwsMtUAx/oixoqgCb3jJktZ8IwlCKMJJYD14ejTeszdXYDxAh+ASyBEg7NxMKlNY4A/YlM0SbH+JGX6hjk56trMU3QVkmCHNhEmTYnVBeMGkgqCVO524gMAn4EpjE1g70YqAuMl9yUtNh9DN1aK0Y3npKMVZCyI8tnlWkKnF67miUgXYnMBPpYQAUnSDcT7kog7IhouVT3fEcom2TZQnFLCVAO5j+pTwojSRnQ04OIei4QkPTqJ0OkATXmG8GRCLL7O6YXT24rn1NPJTQM+qUlS2lwwQgOJYTSkd4RpFpSgdxSn6bSBGNeWvzbB7kfEb3OqYDIMgcT+NEc7DaY6bB9sR61oO2rvucqgZUzpGsO5nTQ1dweWIyLN9uBMC0q4DWctLoN35I5FA2TotUsmjbMJyHG5XO2oWuQjkk70dpJUZTYoC1LVU20KvUUkoKSNcBG5CsKwOcYpleiVQQIjggw4fENvNK1K4TL0BMyPBgLJ+zXKV49vCuB9yFr/KqhkqBb8iTlbXhzh581VQtD7z8fnsoESPsaUmTL7Bvia0lps9ld6k6cUy2fU3tN5knj9h0pcW31+elHJXDHWIGsDYXL7G/CvZhYBfle1CD43/yuy8vdMZlfJXTLu30/cMPoz9rBD2Y17A3FQbxAPsjUpplSGTb3uRNzJCw+146QJsIWOrmgH4ZQIFXDLuAF0AcZyj8puMpgiKCCyo5knEucfGFcqINzuwkOnmx1RyZhKePrShrTgqb7MlL7uZMN9VBMGp+D0uLt1etHN/zCggtzjNNUbmfTdkAHSSPCBTKQWJU02EGGJwX5JiLKFrVpVmKtNEvTq5PjyNZIQS/eFS0TFK9DQOFMjXtce1uaRPsFDzOif9oLkAk0kyRLOpmN31AwRcNThJ61huUGkIklBqcIauh3ndwxo98K+D127rsKiecZF8gw/LsaKDFcauSsebjeBFYs1Hu1QQeElsZ1t7D3lROBlou+qfNO4GrtqUXSUIuOJdr5OAwvujODbub3b2h/Yr8CDL72tw7Lb5XZyqGbyXcrjWyTIHxmRCizFSdZPaYyOz7umMu7D1dVFF22hq7MuYBPymKdy7qulrvLKjuHx9NioLypd1eA9VSNT8Y1kzA3Mj7aNh2Bmeps0j984tVm5cZ61Ydqt9rxySWlMmKzrESZ0s+xM1jI3NtTTmsGLxlStaZcIJwThO0zTygK/zgTHI4K2o7lT7mp9gCKFV1rgE0KBDkJ1vnNx9unon73j825PH4Le1Vl3Xt4EgYebuC4GNy/dBOjL5ZlePfw15PFwrf3qVt4G/q9ajHp4bdGbu9YGWA3c8+amRAmPs7xeuTgbuGv6ZG5u5vuJcZXvooZ2IkKERYxSym6BH5N2YQhMzSOWEUHf+Sb5JWeRvMAIKkcqXd4GYdE9vaUTklAccTHc0v/aWmh5tQVWG/bM+czOlUQ10ISnNJ42jMViLAJIRPS3rna34GQ/6+43Ja9jMu7nUGJ5gM4GT3sXVuX33hvra145ZdkL0f0Q1+HCZzF4GcGVIPM7wThPwWVgMB2+fh0UFWb5Wmi3Wub/zyu7etPWruAUm4y1LSTIHZWzpkOfaK5h70DUxHZyKbMWfYUnn5ABEg5dp27+myecp479nF5kB9mCpX3pgUCW/htD2DsVMWfMLs/AG+rGFUKCDLGAsKwk4LbIRvB5s/59ah5ujT4dpPwe3uVEkntS77lAV0cXdtSGhQ5zZBraYkLv8gwayqiiOEXd/zxHExzfEvVKOsREO6geMKfFPPqYveiNrtmZrIJMpyV5/K9cCzi5QKIctoNDhNL6RwjHKjO4C5JYZH8xRht+vA2tP+BWC4Z1VLAZwqWB/Ld/tt6jVd5aiytMU5lfFnZEQwpgt7OhW+B8ipAPGzLpFiYwfjVwYUcMYM7BOf13xsymgIcvE3W0364aLBct46o05ABUsF5Gk40462ofmeG3HAvFtzUTJsNJgiQZY6ZobJ6hHuCOxQyRB5Oq2CgodSohtDbIUv2xO6rZpX+S/AVaM0qEwoXYm4ubCj/HQDvUbkxmVKi7SEzg1D55SkXTFBETrjPYShAxAF87COKCwAY0Tb1uwpOJ4BNBsSK+pcNSTvfciF4LGVRwGsyVaBfMh7cLWFF43KfDjGcynZpdDt/x2h/ecaUv4k6pVHo1Ty8aCLu4HYSgM0YfkOR6/0QI/WcucZze46k0Af3iVY7vHU3uPNxE9hc3RmRF241p6yp/uk4y114BQuURndxoUm4iQ9ZNAyVkQuBVAHFrSyDOgoikvmZnEoewjAp4i4vkDlmQHDMOwmnKPZU20MEZH/NMWhVh5J7/2hNoNYgd6FWne/66BEsDScY4HuWRKSNKk+VJKm7uvfb+wSzPYXjmJWINzJ+t9CngpDpj72fOhylBZ2dHBSlUJPvMk9v5KILhO0jrASiVAIsTTqLdCEZhlxfo7W4x4ALb+SuULdxBJ4i954inQKXdnJXt11y7OhMEZRDiw2iQ6cvlD63DAdkpGNvE8Fn+fpA7UHhsn/7G2PbWyedIiKB3AQS+R5c2mk2bNkQrEX1/CT7OjVYmaDzSjlzZfRpwHtl/RLH9jpP1kPAopmpaV1OmI6qm1bvyI2dKEJyWyeFMUUZYFWbQSmi6uufN1CRrAb6Pv9hdLgnMvimr6T7vzOsAFJmpScDnhW5XdrIy0VyoEepA9hGuIDJjSkx7VPK6ZH5kpkCn3U8g9BKFR51Hyapra1qSKlf5CDOclCUFN1vJqSuRMyS8FwLnF5EHORtSlSXGBEuxgn+UY/j/jTZSzjYOUfPNTrTf3n2702qgjRSrjUO0uxfttfYO2m/R/2yWiKwxLrf5RRLRdKbUTMwaIyeeBsImimQMaz5AQ4FZlmIR9rVTIzJFMYDYaU+igClnTR5VjANSYYzkmDDzhgQVHCk3qXV9InIkMOet5MaFIS/NgXVNrLiBYqejwsTFcw4QlvqDxqkCH0TbLGOwbYaEO27LGrfPpeKsmcSltZlwqXBa1ynbvIDhjVrDUvKYFvMEPcmFVl+ZNpFza99mpfiUGn0vufjeLeP3DHI5kWbFgLEJ9PvpBQp4QrC1wZS+w2KK7mmiLTi41eyphsdT82NZfge7rd25w9BarIIMKWd1KrBLmOEp/dX8fPQYXTVpMEtTpQL7nJE+Ke8/7dX8yWe7eK3mWnXlNnp8/3DhNYLLdj3tnHeCz1USby+qrY4YwrWMt95lhHHZ61BB5n+2mnyFy+psiDwxasY+fHV6cberd/vpxd3+62JOxBjHdZznj52jamJmgvyM2wC+sSrNSbt8f4TetHa3AX00Gw4BxfkQnWjniceKKPTKhl4b6G2zT3MTVdv4r02PR2sa2afZe47+lU0mRMRYkv9CI/KAXeoxdLmTaEjvXKw1zD9EjnwzsUkGz5jtVUyZIkMiItTN4phISe/sB43rLskEC9clEPsRR9PJiFRo31ar2Wo1907gv3ea2zuFlWJYRUvkymxeCcykDUpBPV0YROljfVGcd658bNLiRVLrneaXH0cTQe+0uj3++PvrYDmLlw6o7pTjBPVxilkM116QUsEFEjzTt+GMY6/5nPC5CuieVagWCgCqhF+uCEx07xk+brFU0Xx7IY+2WLBXXoYliyit2EN1gNBs1RERJOlV+dIrbmxOhyMiVTCpk5GZuwGMTCYk8SRnffOnmTIfK75GUAICw1mvWlslGzO+7IZWUhvhLx7vnm4i14ANC7CMJKZSWyW29TlE+lJ6a8tFTf6EzAYD+uBHhM+8Gik1OdzaMh8xn4i4GL6O0JVJLVXcmFMPdOwf6/pTJOl4kk6Rwrf5uprIYIqlAuWa4j5JpbGcGFeQGmgQkDX3V2fH0t+jGzGPstuNsvp7zNX3Yq9zN/hJYNN7x+CJQInLSgsM9Twd0aQAkoeYTIxD4cMvNhWiuFXsdo8QOmXaQsVC0eA5AZUoAOVh27Tq/2//bjPXvPcCbkaW2sr4GLP8PQEV91UjkIBtiSDLDPVJyu+rt3n1mSiem1C2G/f39xHBUkXjqR3BbAxzMrBUG3kX91PbkNaMMsI5SLbh1ZQ7uWlym21DZv3tSGb9duHwNQqbOCevALBspRCMsdEwZ45xpASmqT4yEyIor2hXqxmY195TfNIDNr6B1iODAYEexXpWu1Es96/I1dnx64Zxmby/lMvdC82ojoZ7bgQloLes2yvBIYnKCnJ2Xj9sUGGsVwn2wfetGUErPqYU85WYTz3C7wv7JpNERPVumTBKl5cU+0znIIcD8cFj1yJm6Oy4c6FVVsdwfOyHCvfKZpk7MsY0rYm5L5oDmKDYRKdAgNaeK8Yu+cbvLJrNTZlfAxBqeiKdLu0TodAJZVIRu7EKEoFH1L9s25k8mtr3nWGythyix7tz2Dwhm0YEDztbLqu9YnsaOmsMnIYrYSYrE1EnDJSVFGgbqNGB8JswNVCFhENTYGXUEkOYcTYd0z+DjHQjQv/PL5IMslQfhhvggibmVRr+obm78SZAzNnArNVskiNLKqwq7fxVbaqvItKsZivZ1YIpZ093t9lu7jW3283t1vbu9u5Be/vN2zfN7f2D7d3tg93WbnN7Z699sLf/5u1+s91qtcpMrC4k+I31YHekvU9m0exTPqTsSVHhiDyqAwVPa8Ob6Lg6StjKMJN7lYDoo6X50QKKW9rHDPdwMqZso4E2BAGrmw17esCvVlWEOXMOgDFImnO/erKolbhvl1KwVPg3U0QCEYo8MzxoN32PJYp5mpIYgI/sb6+gm5odGMr9pjxDA8oScxy9ckj5UFqt4LvuuLmhHNpkIdqTOuBcMa7IIaqg376iS5IOmqapnHXj7Ocs1ln0k4HNsL806JDRTyhPfPaCMF/Q/FsMSfsln2HjEqaghDfm8PSuBZapITcwEqZoooEg986YkunU7YgP/J5ASatyjWOkiQnNQ+84084qV5pnrfu0QnNrok1r4wFyrmbkRFSeE2szfwsrb3L9ClvLdruzabDmjSdvdiNzweQk68XQasBD+hUlZocN5eYLTLjw2ZiztNmEBYPsYblySanm61G+AcvU5Wv9FfL0oKVFdDSLx6izm+RJyl5wjlvHPgWYUlx4CnVJmNRvyuJ5B70w6/oFcCjoy+VpXszn3hpe0cnd7qEJ7wr0Lzq52/8v+Odrk/wmiMki9MMCTsQrkw4nq/ogvdmOtvejVrR9uLe7MzcUNWF3VHA2JnP1oF9Ipqd5WpmpPPMzWjGHupZKJDLGihBFNqoCcGDugyJjoII8Alg4sESvLBSheRlTeEjZsIE+dxrBdXxHUj4ZQ8ETUXH0ulGiT/vuvieayTTSVy12wDWOqjziYE9ZDlJm7GSvNLUaC2o3ZRD31twFk5eXOGdp7tWdjMiYCJzW2MDvxM1RMu2CE/OKDgACiDxQqbfvzHGhCWLaVk3TqcUfla7JnCAAKChNB78bJ2BtBCecSK39y5J6i3cHe63WoCCMWqzaiv6FvkIAtnG+JU4Hszs95uOJoDIw/fnAgF0wnhCbfVFgOdcrfsuA4QCBm4TICsHar5SaD4bEWASuMb7V97pCEy4l7RuQPG+n5KEoba/ojTwmStDY2C4A8DRjvRQhI7ThBAHjOEuxAHr9kGRMFSS05gaj/9s5VzaxmhpsC0bMlS0Jyb9gT1KBDIhl84LY8/MfpHCbimnjzGKFbvT3rGelHS34p5Y+mNm4Ioia7Lwhe6Q/IC1M9uPdgzfbSZ8cDFrtN7u4vb/zpt9/u737ZrBf2I815SwUYhJus5nM9ydvLVLK2LS71J9MsPMBGMTuF5ym/N4sv+9zH2xmr/RAqiIDLAEfDweUiaKXbCwFV4/g9Cy8d+YnhPkwf3hDWNMFS+DgJMVS0dgibxROkXOYw8i5eWjMpPJJ2igICr8jWMmqQUxo1Sph6Lw58SiG/qN6IW9y196gyAz0wTBvM0Hf0orgfMhH0x634ibiCak1H83tJuy3BEw5o2eCnaDuudFF4QUZXtvMps/7v8ExDUouQ1xPSK8CQ9vAmzSCRXCse7WYp5P1XbdVP6i9TjxlDuLGjTbfXppRyQEJ5R01Q4D+rFnzoP6uuFHtHow0CXp6WWEg6UuPbW7mYQWA8rZ2O7ziAXN+tsbMqx4XjkgLABKCjueRDA4nmrJhRuXIr1p+KOFI6/sCZZPCVW/vOS41qSgMOFk8RysXBlYw5C14lVC2rSp3Ta5g3O55jZpGK3gZW6bGmJmiLUkqzAQ3X7Nl/9Muamjrya19jtX6HFasa9fjR3Y93CKvPZDniGvto6x9lJfgo8y/Y9dezNqLWdiLecY2W/s5az9n7ees1s+Z//jJAFx3pSWCBrEZwfgz0pgbmNPSWBM+OjwTO/ykZ99G8MWZtl7GLq94Ay7YK95SKDxCGk6CSU7cIp8OzCBc+DGwIDPUzZ7yRxT8vbPgbgq6++Yruv2ZC1aJ37OaNful2GrOLZl7t5/Dm7aaXnGUcn6LsL4aDR4oUebZdObFPuhu5++Qsrx2ou1o7jaLf92p8+kt5rV4HQFZbQTEinUdAfmRIyBukdcRkOeIax0BWUdAvpMIiN2x6wjIOgJSZwTEbbN1BGQdAVlHQL55BMQevxcdAbE0riMg30sExC7YOgLyNTmtd/RL2NFPIm7/TfarD8rlESJXbpT/5olqI/MpV6jj2hqVoJ6RJKbOZBCgdTuo4y0DuBIUeMhC06QAe1lvDFyEg25YvJYQwB1AL62ZEIKhGKoKRITQ2HkPv5CpAF/6K8jSIZ6NhZfOeXoMQDmYJeZM0gRQHbTMtGuRUkbCZsAGJdiO2nfQy1BTzIp8y8cmdGIoCtPt9RAp/DSodTOhJz+2izlYyAuHJGmwr11Vk3dYoIzONJOr/pyTgufSwMZ5cX9fONJW7msc6TWO9BpH+i/FkTYn0bVqz5XgCwSTNqSuwaRXL/I1mPQaTHoNJr0Gk16DSa/BpNdg0msw6e8TTNrYhy8ETBqIWYNJvxgwabs7vgKirLUyRF7y6497fOVKIOWgtxtSAkNskQ1fPLD0o+KIlpTHCwSWnt/F/Ybo0lY/oJeELm0EtUaXXqNLr9Gl1+jSa3TpNbr0Gl16jS69Rpdeo0uv0aXX6NJrdOk1uvTfBl1ajQTBRso22+sq/83j2V4b702Wjj6mKZaSDqauAAaK0FIi9I9xzEXiDCs7F1L4gTM+nl5bCq+9UaQZ/nh6dXmCOldX/+fon9cPnRM0EHhMtE0VXbNSQpjWBprfAiX5wJYOk9/kvRwqbAjAxcROj7sNdP7z+19trZ7La8co5uOx1tKW5CgfGuLLwFCkcKxoHP0UEjYmmEEjf5cIp2wswhrFrtU+4oN8TOXHtIRdb9DxBMfqeuN1VJiRxCNQCE9Pmo9sUnBuKYMoB9i4OB55fOj+1D1TKZN/aOZpwLrFMR9PUirhzSYfcshx6skkLIEXRpQQprWn9tNMwqEmfeN/oSVTtvKEgnnOo0EGrzx1xhPQMsjfoyhLtEvNhUS8/28SK2nnc6Fjm12IWVIw/gMgaYhcuyEpZ1tBBsS8/mHAY+RJmoNbQ3MVt5/gL0H64yNcV3C7HNXR3ymZaxkhvfTsr+USvBaWjLPE4rrs3Y28bvy6p9Va746whIsmI5kS8GbtKLjuCQCjv+5lEv4n0IJaD55zRrbO+P3WR5LQbLz1gQ5H1z0Z4zRP9aQMdSaQEfmAOu5q716d/oa2o3Z4wwXj/mII8tncOUUIBvfNEEz+FZYozqTiY5dvfM1OHiagzcNR7+z7uiCH1wyhnyCzoOsq+9yvGDE/nfF784PhzfysGdyYXXnzgeVWPVihmpb92KVhmKvWFkiYJGct4CSL3dtiftnOsnp6gR4i+H+QtG8aJkD+SUrviHBqtMOGKRHo5J9LqlIIXdSMUBGgKHgzzVNgn0cLIRT0ioq824XfX3xg/XjK2euS4CYjKkf/bzb+v7BgBjQlEYYXWjKPB5/kBW5F5/MMnje00Q2BdJoaLA43dGUROOMKLEr9aXO/SHRLyAQpgeNbs6v012Hc6CvG+HycKlu4XB9MiXNJQAT5fIEAOv6X9qkgz6rpT5GPYKAPRJDNTQnlm6xJHkY4kxCaceaX0UOBOaXtJ0EQsTrL5KW7pJ9DhEU8onekYdAKYF0aecyogQiLxXSiSJIH/ckDiTNFGmhEk4SwBhIEJ+a/9TXXsHZBA90LqioKYzb/teE+qx0s8+mvOlZzrWXME9KTdMiwNtOjhA6JVD2cDrmgajSua4HhPRRLsPT8ZL7ES9NjQuiCxxAm9aKcCciHBbWeCyjx1T4T7B4qkc2m8E84UMeQB1CmQUm1/qQA8A0b08+BV4xscnLL6yRHeHtv7nLX+VfF4Ih8JQjS5zwlmFWJ+535U+gEUqjEcjNoIdmElrKHr92hGraa/omyYY1YLXqTBWGqeXdX0KqogA0S4NlADfQAx5oRk3yDJB+oe603jPkWBWMSB2IgkSApubOucWei9+JPn7pQMlf1/jKO9JwkepjE0UTwh2kNq6CwyuqEm6L6x9kopi/Bi4mwFVsEGVKqV2OQmTeslA+HkI2uVSwfCjwZ0RgRIbTz6LM5w1HvcEqTMLuWC+3gS+XmQ2cE3xGUsaCObuDytOCr+VdcPnk+vh9W39MZi0ckvq3CpTi5vPx02ftyfnX5pXt1cty7/PTpqobVzMDPriuvsmuGL9SIQKarUZslS5zGgutzgY64mHCBn9VQZ26mFcHjmrWInmKVqgTG48LqClsW6xSIxb8Kep75QZ+pQU4+f/jt97cf33Z+qUHq+g5VeDxPxuBj9u6xPqCYJcbkvfeVmG5LmbtJn6whYcRkOkJ9Jtzn5Ztqu7Xdbrb0/121tw/brcOd1u813FygC+Yy9J+4kze7igvn/gX6qELHoHhUzHf5RSsm05cu//pj33POuYmdQuCqYYQ+orkRVMhEcb3qco2obSTOU4tRgm1nQQTqzlhPRpmWTdearAfQzUuuQLVZZJ6Ah1ThtGggaY8aMqLwEFMWFK5BXTRl2vWAQGwBravydsGFZfrK1bE6EWpvejkH9b22qGEcfY+DRzmvTwrFv2aLFr6/Es70SCt2vHOv04JCYFNiA/AA1a64A/OzcWEYxu4I455mE00BuhnrqW4sJhjV55JIdANcBDAS+hsQVfs36Bv3KAeOiv5oA0nKYj8cJCmwnG6fj6cltAopJySA0lh9QMyiUJhmoUEacchGyeNK8CoYc957Xbz5LJAce8r5pvYtIUKnvq7d5nkaTSTCqJapzmxY/zavTCrJZWvEx2QLp/l6LSUfTUTPTL6siCqP3zEU99ra0ydkdJUXX1FprilnD+X2PUO/UpbwezlTC2KiBjl2gK/XMNeh1lmh5GOeVpWwLfmeAPIk6SCCMJIi4ELWtO0+4ngEUB3BVO40nZy9rz5RD2/3m/tzowZ9hcn+VJEeF8ny2+YRFt9NteNI/sjgNYIPHufrjCqVEnTCEopX4YRo9uJJ1ivjJq2MuaOLLwXopEd5O2WKpKviyV7OvaSEwvasK/XkQQkM8VNQVh5B1ReJ6Bk3pb9YI3RqiLHhu9znUWAg9TOaKoO0N57Q1GrM2OEP9wka4FtjqY5xCo4UsMKFXPLZw4uGPEy4mOvZf5BipQirfvk/s4FnMxxJEEkJwDCbODaY5tMJWRnZI4ITIiLcp71KVKmV7dcZYCm9XTtBzOydMZHhHXuAY4Jedd6dvl4xl5B5UxN/H2AKk9zz2JlcERtBy/uVGyPailVYn8WABzvvarkgTIlpWO+/sgI7uxT5BDWvh8lsqfn8bG60HtobBj3awZs4fuRKLPiQI9nDfVoTJ18/9m69zijLHtCn7orXq8Zb2W69py7mFTHxzbX1apUAHa/0ujTD1X9dSltbPAfdj2f3bXYYwvCIHaa8MZshZ8pxcDxCdrLyRip4LrdkaiNvufdin+ssapokPmEwBHbrT5HM+k2Th+OHhIJARrAaoZuQ4+inm5VpGT9mPKLbi2n/Qtpe0TAe0ab8I7PB8j7u05SqaY6oXkC3jMPC45WxpW8ePpknYPAszrojzBhnyA6PYpzGWWrrDXx5dU08DVI8rMt20ju7azc7nGiYbOUs1FiYUuIgzDtcGQMOhKfHBwNJ6mpWU+LFzFYfN5L+Oc+6PAdbr8SDxy/Sk62clRotihInBqR4xQzcUaEynPbmz997lkVeYsLOVyx1rIGfxbfWAsysdmsNly8jmN/QgMn+akPDcLxaQ8OO+Qy7bdFDaoXqZOm34qpZqVnXzLCxUm0zwoIkvZT2BRa0tgRR5xOY6ZCfrlhDlPO6KvYUSQc1Fp+64ZGcjvs8NfWn+giv1MHU1NYZxYA3Yj9LA5GHOM0Sl6yQEgw/J7y6p5XPAoHHH8g0KsBv+IEleuUSuBUW0fDP1w14EfJjelQE6APg9Zl96k/Qq43hnxsNePfZMCNsVPQdnAQ3xOJCH3Bxu+Kq/plrQO+TW3gCznPuTH/HGbhDHLzK++PhhfaJmZBMI+jR6If2aU/wlD87UWl0P6idBXXsy7pBA9fLipXeEHaNYBpXlw5DWvgW80CXz+cH1t8w1SeQIlvk4/zqfbdhNAG8jOOUD3kGr/OYoU4KaFuKmIBoVwmCx+hV57j72qXHELfkflTT5MB81JR/uyfKf2dSaW8tJQn638edq06EfueMRKd50phpcDeGV8tCY6D+1L1YQuYApO3btAGJEn7PUo4dsHGxFAx1GOocd+HB3OGB5VK37+ZcjA/RzdHh9QSr0bXi15pmcF78WTqUfEx6fpPeGAnczPzWj2zf582DamguuCQXdJN/K0I35Qldeyk/ZPBNfV5CKkpfmv1w/gHImct3R5am0Fe0YT+of75pmMSK8KkXNl6AzBAc/3ARA5d9cU0wrC1T8ULQMRZTi+hweoxe/Xx6/PrJ9InNdqvVXoUlltfS1s1XmHtaydOqkh705RuNk72auPp4vAf3+yqudBhHjnC7Jlq7HzrtlRObV0rUQO723v7KCd5rzxPIXJDgvfb2igmWCSF1Hclu9/jk5GJlBFNWwiZeXUEhK0HZ56lFuaXpehzMKsjtvf2dtzurUJFjOiZ1Zot8PP14Yl6lXBpZmHFu8W8DxYm4cKYMHxTCbAhBfTEaKTWRh1tb9/f3EcUMR1wMt7CUdGi6T2+NSUJxE15fwp+jh5Eap/867fiWANoYGdCY4tS81fxXw2Z5ubSQCP2q7f6xSRHFDOxBYIZKV3jTt4BufswxlyrvMRWy7jBxVrFs9W3NjwASPijsRx4rnObbtRo1dbO1v9tayZ5cMm+2Im3W57tqp40npk3rCkj9RpBTdh1CjzVwZbWL40qXfNJoaXmcW7oa15Hfs9rS58BVhwk2wbsTlVgKq7KotPm9OkZWjyrx3vkLYQJ3Y2Y3+LBERcZuIfSQBDmtz8vY3VrtBpqQb5FsenTxpZhoahpven++Otl0JZmmEyjhn2BWV/72qUfmNtOUnJCGa8QLSfo2Q7FpyiNmWK6rKG5CvgFqhRfETIeTBeRwgcM2MEvxrf+35tQsz/hdMWvmmUzvRzvRwX6rFbXf7Lb3VsM9HU/qxEPsmCi05dfm9ADgIbo4MacadRiyVKBmE4Ci4WMooAvpv8x0ch1QNiRiIihTpn4KoI/utKIcKCKQIEaYtp2j66QZ84Q0gc9c3wrMpK8vlqZ/N4/jTAiSNCzmmGnLamp0rKUpsA9hAvUGC6JYvSWsWYpVwSAeUEHIFDTPVj/lwy0DVtLUdpvWg1vbrfbuVqu9BfE8yoZNm5bcNMJpWviDSNvKFb0a4v23rZ14lxxsb7f1D0mM9w72dzBOdvaTZLCavePSDHtwhGo0sfz5WUZzdi86p+dX0clvJ6vh3hba1s2ynWYZ1jf8rQFAhDZaDD9/mhCDCoW6BhZkBbJ5/pN6xQuQHkTrCfAsC5H5oGrH2EUmOqsHhSK2Df3PCkDq9v7O21XYC8Yy6b10c/TKGFBgkGorSk7HKWW3K3lurjEOAYsPzvgrs8sTKqB7gKW/jMakP7YCnrLaIutXDn789Bi9+gJBdYEkiTNB1TTEBXjVnYm4G+eqvrj7w17rIML2KYveGR1e+6u7hYEI5rXJuK+6nfPXkXGoIdDjAZmqIDNwpkYcRAiwxkFFNGyffqbyBzOHjJw3oSKygY7PuyjkGKFXtsFaEmORSPuUVwAMyzOF8+X4KbKd2KOYr2xZqJQZEZFhoc7L1a2LhYiFe+bV0TlsRE0EAKYE0vVyLwnCtsOHCDqg66GOlJnALCaoa5piH83d5nNu+UCzu9plY7rrvTp6DQaknGX9S3fFfAXQVCSpc/mPw4ns6h8vsvpH//jSbaBP/3C74JTFDfTpyz+gcUqOlddAR+f/eGKn+LNY146BdpU5pE9dW8ZN43Tb2euSRao3ldZKv1Byv2ImQzzWmhkNp5Lo1aclFMcpi2uUA057GaN1GexV4sAp0jNqqXxZQCwzJ2fFopEKQ3l1D/yI+iBq/b2v59Omj5vP3/pXDdQFG++idEaOcEoHXDC6CqAG4J5x1YMAwRzsPvZwcUXH4NGbyMAsbg6ViHFwbyDcwCRNoPEUgM6UFnm7td1qtt402/uotXPY3jvcOfj/Wq3D1tyNWudhuE8GfK7Y7cIcD6iQah5u2wfN1lvgtn242zrc3lstt6YnUu+WTGuHoeyUkCcdzlTYwOmWlA/2ZXdll1rAb5yJu7oOsfZhYPwgR5Ygkqb6A7H9U85xAHMJqBv+UqcyAOx0j68l+TAq1WRvu12DkMjDhDPy3JLiGWwCM4Rf9oTAY83MonsMtzkY3t/b23njFoQl5GGmMQiPeya4ONswZHWCWTJqA00J6Z8+RBXsBTnBsYnlUFX2nrZbu29XxY4kguK0Nzdi/xINbMxUDosfrlR/LKpvd2j2BApSKsLiaQ7w65qrm4xI2DGTEWYZtGtuIBrWU5gwtUvH5eDkptrw0p6qx6TxQ8cjDDgaoiz4vb33794dHL05Pnn3vnXwtnVw3N4+OuqsTDN59LPaFfFpsS9VARXUQ7AFGulXYh4HxkTLTIa98IxJMuAZA+Tmnzk6w2yIjgAw1FYKTCPUJcSH84dUjbI+RPKHPMVsuDXkW/2U97eGvB21d7ekiLcM4uiWFgz8VzTk/3G2s/Omebazt1NuewQpaM0VXhM26PLXhBOkjyc4MmYZNpUY0TDlfZx6m5eRVTzxzfD/V4QL6osWOL5eQrighMhrA336cD4aL+he/SO38Rvo7B9dzNB7gVlMZcyDeEJDe4cRRA++2W55MaGCglBWzeVfHSt4TCkUFr5Opl9AYGBGBitj82/q5Ns8i3otwQACRU9qTbPSNt5ZlikhVU8SMs/ZfNR9NyVRs3DJlCntwg1NMx5brQWOvOnCRwAseaSK3YK1V+PJm+V2E+IZ7XaztXfVfnO4vXe4+yZqtZZGUh4SHsVUTesCJz9y+recOMCZEgQviZAH9HOmqPYce3EpLXglTFzd86aFwYxLeet+9k1Zzej5ktZmkcWa1um8AB5vJyuzwoUaoQ44UEsqFcMV2HM9KnldS3dkTcbT7idYu7K5tJLVMXzUdYYsD5W76wgzvCzcruYB0FxLlkqJ/iHhvRA7rnhbcTakKkuMPkyxgn+Uddl/o42Us41D1HyzE+23d9/utBpoI8Vq4xDt7kV7rb2D9lv0PytQbXUW936RRDQd1MJM6iVGTp4NBxBt+nryARoKzLIUi7D9hRqRKYqx9qf7PAtLZo9chEKPESQrUWHqXmPCFBHSNNUfpJwLGzxp+PhH4rqa+UENeWkOzmJ8iQaKvblcLAPPC1lNdI4yaKQ4hgLmIeGO23J6UJ9LxVkzWfIFSi/mhEuF07o0xeYFDG80/Gx5Niyg47EA+Q/d8vIMcptZ7QGRx3jqoVBvGb9n0C0NaVZgIi7Q76cXoTeLkE2WsH2z7mlC0qkpM3YOMHS/hh/LAj/Ybe0uGfbXwhZkqC29GlXzJczwlGZufl4S1zlgpCbdbJmoVM2fM9InK9j32rD8k7NaLBvXTlqP7+7/XHW5xsunnfNO8LlKbq1VsNURQ7CM8Na7jDAuex0qAqyohaRA5ymZ9B96duvCPH2p2LcQ8YE/lE/0LWxH29FOtGQOZIq/qTsCEBwvzhsZY3FL2TBSaV01shtXAg8GNEZnmmV0IbjiMU8hUqqteUuBjNClC2WbR9e8K2rYLhX9hH79cHp1Yjqf/nx5cnJufux8fHdyaX68PDkutUP9dUTVkq9Nroyvh+eJsKxqy7hZw85hXh7+7vv2O0dv5DnE8Ngz29e1BKCe+B7RC2iJ3d0lIxY2L72usMtV0b7M2d+ULiW+vJyp+LOXiXSEsyU1vCDQz7G2QNqlGx99uTxDKWW3UDrIQ7ycqmZ4T25m91Rly9SDnKIt/6WtVqvV3t5Z8nbQRozU5h6A8odl4St3az45kGuYBZqfKsKMGdzHkuzvIsJinmg9nVvC77nwcDmOWMRNFQRnMjclukSB1XzyACrnkgw/Z0RM7e8axf5XMYdzxlni2/dYBCKtoOBh+Cad9PTvbvLEAD6xC9rPlNu6QWNRE8gRJOZ3RDiUWmhglqPr+bZQWqVdnvzce3d63rn8T8O5vxAqgGk+v8s6R63OL5/fXXU6nQ782/znH6vcAQYk8WvNR13GdeU6H7mScK3v9SrrA2HGddDNXmYXXh7GYDLYhlXfhOWxS+VJht0hKRumuZNjP+/3iklMf6Vl3f29ATI/+e2ic37c6/7+2gJG5QuU00BVXswGkGIwrp3StiCRJoQOE8I+1qN//HJ2dQpzwdhuOOju5Ee8w4ICKH9K2FCNzLA2gwB4zTe2HvP410+Xx2Zfn/zc+6z/VSA92ITBHvMeZkJiOi4BDaBXJBqim432xk0FEtrmvzaODq+FwteCJD2lJtd9yq7HUzyZROSBLN2PuLjvyhUqq2lhqTBLsEiK28HgZFpd47G3ZgVgdsyKmBzR2VSvlfDX6fcFuTPxBLhjXf21nq90rXz459nHFfFzS6Y1sPOB3pGmIKkpMoFSKD4AmNJyysWn91e/di5PrvNaOXdNnF9dH2VCEKbsi8/16RgPiSlVOoHm3Hr3f4JJ5fU9ZZpQvalXJJxyqdlKpPM+BzjLQQpMc3JI4WP2+qha9uul5eVVTIXcro9JPxsOl0VM8wIM2ajrMcIkb1krpLS9VsOQjDFjRPSkwnMB/z7mRUCgXhPe+WXr5PjSNpJ12L0ZNPwfZGk6RQlRpo39GKc0pjyTYb0dtEP+cnlW9iGW5NO6+cvweG48IL06dAydUkMTGQBmeF8ScUcSrbKTLLboTuBTQY/SqqyV7SVDljWWTm5c2aYiBYfQ39HGDD2aaql8As7BYKAMda9Of0PbUSsKIwblsMKhCRPgTHHGxzyTTeNP2F8LRQc4VuZfHt6mFIZI+BhT1tQyMh+F8romThJh/q33l/mJTu52gz/Qyd2+/efMmGMcB58bZ4o8mB+1L2x/Mi2WzT9cs2Tzr0yk1wyFQ/4E9ZpNHEPw2nzq3mi3plMqzVsyNX952GsdNIPEp1IQxfOx3NbJRBoZ6dXlUh3D6E6jZSLNrcYNKEbxZY4bgdF9ypDkY4JiLCEsoR3XMZ4icJUtXurphb5Ptrgw4QmzPdJpjomEUYE15EBymDm4ptEioJfmMVADyTDkzo6/MUPcmCeNkELDkCbMVoJqOlOqiMApOr242/djEhan3Ka43/zrxmCI/tcNenV6cvUeXb4/8oNuv9nZfm1oCj+YZ9w6N8A9q3joYAsc58jNw1JAdslyLkp++T1UO4Sz7zyeS9tXNPvJczxa361KaDco6IwMG3Ae/Oer8uiuwackCtEBospg/MqG3syMK0TuiJjqKQyS8Mz3ZwZ3006IoDxB40yaLsV9h/ZFEuNyEZezlpsE8OE+QRsTNtzIk74BODrSv/t7AFnrnTcQGEDj69p4FwbwOVBgFgsGjtt/3ATqTPHJxswi3/zHjandUmiCRY52aIletucACCBL0zmYn4mHrB4c4nRg4I2/XJ6ZTgwGVQYzpXXplGdC34C51p0GGwfgu/MIAWXoxrF2A0hlALOjCr12BYk5k0pkYEtCemDYFgJge3I2TBz/0ShmUR8e7u7ubBnQnP/7xz/s782//0PxyfJr5tTTS1i3zS/MP2x4tQnbXCJJ4D0kl6eXY4V6oQwxou65uEVjzqjigrKh0VreKnb3eJ9o9Wi3i4XexDLcABg8BpTyoc3v0F/VGnigCDPg5qEZap4psBoVDmC4X8bEbkX/NT8slq6nqyO0Aeg3KTGJp4yrsvZaaOvo0R758/K7aoKlDBTcylGv7fBOidmrdcn8YkP4XLg3T4V0L2wgJiAs0MxW5BuroPXZj21fb+6j75hHid/dLRfzLP2epjn5IyO1Va2AvQYT2APo87CASfMXG5WuYtyfYb16MweldMf+X7hjjVEXNiUIZ4n0/YSL5jrj+rugXUQefjCl1gHtkbX1hamjg/n6mfKfagSTGWaNWehHNG0oGCLjicrpAdLNJ2/st2fQ6BI6gIc7BclVfaLuSdCFWk+q7rlxkVZhSBgvlAiS9Op1Ca8g+DscEdDhblK4c8zEDRDSZEK8rpFZ3/xp5tmtYBsHY5kPQ6h5Y8B5+Dy5AYBe4S9mrwxjY9vFSIgiYgx5jhNBYipJOnWNRVIqFUrpbaFOV2aDAX3wI8JnXunL4nBry3zEfCLiYvg6Qldi6l5jJxPBH+jYFHtTCS2s6HiSTpHCt8UMFWt+6/VPcZ+k0rzeaDsTLuB7kqbA/dXZscz1YMyj7LYCx2xliBB6H8l4ROrLPO3C6I+reriWZ/0f88J/c1hpjBt6H7ngVyAOt3XrPE5+EtegxiTimoDrHxlOjX1nPwOun3Uyg8TYNHUiMQU25CEmE2MljbhtL2k6qM0cN6svIojbYBAuLTR+maUAinaomcsoT/i77c/ss4XBVdJGIswcY8Z4buAWzmYjkEAejpllqE9Sfl+tKqr1SlH3hLI1sSssVTSe2hHM4TLaBUvljQ0fK7KjFHxu4FXaci2v/dxmlll/W2+gdkGBNQqKICfPXD7Wq3LwZPkYGyYypu8tJTBN8+BDhULAcsnKR731FZ/0gMFvcKGQwcCmJGkz22whK5dX5Ors+HXDBM18InK+IrmTCIq54boJgYoNNUVwfCpCM7Pz5jG4/JN6/WCHfN/3Dtw5j105+UrMd/nA75ffbA4svqZN9sUOv1rvZ42W+NLQEtdAiXOK5ofASFzDI9YAj/ijIyOuQRHXeIhflcrfCiXh74SC+LcBQPwbYR+uYQ+fJ5814mFZJt8v2OEa5/Bl4ByuIQ5fBsTh3xjd8AcENlxjGta5R16Mf79COMO/G5Lhjw9i+PfFL/wxoAshjZEkEVZ8TOO67SHz+mfmCgpfjIkJqY6WHo8lRdgdFZyNw4xTwhIo1YYEQpsXCTmUJZH0cdL0b8gLhaCcfODD30Y85rHZXmclWVVJKZCMl9YzpARInNDfX47w9t7+MnKqrS/bjJB6NClBSmg/NLO8a8p8U+9qrgcHO5iQvebbfdxu7uL9drPfIvvNVpzEO+2dpNXuL9S11UtC+8nfShh6rmXlQVPSJ1g130atqNXcbm23o9ZetL3TbLVarfZCcQ4nixrr6GZEoWxVHcxsDkuMTSDEZ1orKPAxdAa58b5gfkjvIDnbinFWUP4PPZMDLrL5WxoOBB4TfRRrkkZY42qLI/2UeS/eTJjmulgR7YP+aXB64hRLSQfFWhSFY0Vjg+ND4pEJM/iHegv0ZGaKtJVop7Jj0bgI5WMzMHwv1L6rWQWsB6hPlA1E9H1gcCEUomxIpIKyULjQBVGCO5CcsHAGD4eGPVjkcmTh4+nV5QnqXF39n6N/FtZkKHg2iXBKcV3pARtXWpPrCV4R6T0VmBcCBBgKn/gAQfU71JwpkcGd70pbw4JH2NXY9DSOb40YceGh2xYW+LaV+m/a+ptG1+zXEdQocRUOKcgfGYX+yVOewTJlkiBcEBq0oDVEe16iUvnk5r/Qxkc8JDEWCv0Mn97fQPPjRZjVqO0agaXI745nrQEIPpTa8muQCz4cd641oElZ+D+3Wj5OO6eka/TUN2bBn77jHQ+ZaSV5vz89n9taMuKuG5EKZC4KsFTPEH5hc4e7fnHh50NWbPr5ZF9gp7wILu6JlcLxbTSmShDtbG/Bt+UWHIqteZcpd/CwjOZ26x57e7BxeRuQxymAYJprCqx7X51vbz9TvJD/2gvP/NkjxXW656+1P/9HRtKgK7FEBMcjb+5zsy6mOzkpm3ztvfb+wUKCCSMLK1Yhq6/D+xQQW40y+jPnw5Sgs7O5kWFzacScDfQC1HekcxP3uqdG5LpnEECajGRKALawo+C6Z/rDX/fgFcF8PDjT55yRrTN+v/WRJDQbb32gw9F1T8Y4JchhTlOGOpMJYQl9QB2nPCzoRDu3JgvwE78Ygtz7YUARgsGlL01MElNSGGdS8bHxdWV0zU4eJgBdEo5awMdE6CeAjO6aOUjifsUsMMQZvzc/GN7Mz5rBksIwH3j+SgerUtNSHxdquZwvgwH70eGe5C961uyeZe/0Aj1E8P+KuCkJSekdEc4L7LBhSgQ6+efcEcBcEpA2Gtm00fodu0chdgvpq0X8TL+P+OAp/MzJiMrR/1sgT2mmkYkpqiXzmK2PJa1snmHr6ORQAnoB3dCVpcH6OsVpCp+2DhS6JWRiLmuze6DcV487fy3bLHdKCdrPasSH7ABQHh8YtvP5AqY7/pc2zJujmfenaJJiNeBiHKEPRJDNTb1rGGdN8jDCmYRM7NSGjY1eCdxca98Qq4OMPeMqnA8RFrEB2or5eAKJ0kkjx8xpIMLgNZUk+eM5AeAs0kAjmiSENZAgODH/ra+qhr3PGwBBVVEhtfmvDffZjQbaMJ9+BurezPrFPCE9//QcJVT71LU/g5tyRCwh8IRLOUiaHpOQYdB+Hi/aCN4W8wd0aVA3LBYIlfAXkuQFQIAk5Ye0OlNqexU+KSCN3tZ9+IJQZGQTvM6X1uZ5QdKnV6JQz/oY2Fmf85RgViXid+ZPAN1vIEIQHWgD36cZUOngG8rJ/UpkZEVbSv9E2bBXm+O+aRx3n1gx7y6i0n/UfttsBDyZpK4sboxZNsCxQVgB78ZhTlmwtSgYk4RAGSm5s9gHnYnecz996gKeS1UtzjjSc5LoYRJHE8EfpiuSvMIqq08vPw1kPPPeDqRUr8AgMzVMKR8OIYkYElCGAk9GNEZECC5kHoINR4XUzLCtCRdI+6vKzYfOCL4jKGM5+Cn1MH/w1fwr5SwBP6y+azMWj4h2cssLeHJ5+emy9+X86vJL9+rkuHf56dPVilbQPJ/W1Uyia7MgWKEZU+LUYMk6dhCR6IiLCRdhBHdJRhXB45o1hJ5ilWoCxuPC6gFT++uVw0RwbZFHuVbwgz5TO5x8/vDb728/vu38siJJ67tP4fE8DQ8es0ePywD+ha1j7hd9alw2cWIAr+EersTobzdb+v+u2tuH7dbhzjPw+b/Crj7bcxnfT9ylm13FhXO9Av1SlVkUj4qVzb9oRYOV860e0zXme84ZBiAc+H1iqvEKKOWFmmOo9CvAO2t7hvPUwoBi+xyCQH0ZS8cox7JpucJbH/TrklKvNmGgKJgOqcJp0ZjRHizUu+MhpizAn9Pf6FOm3QEL6hysT+UNgQtL8xX1v5zYtPe6nHMIeLwwjr5/wZub1x8EDDCzFQvfX5gb/e0VO7q5x6e17ZgobPqQjTAbPuL6mr95CH8YJnbw89o1zCbQg+RmrKfySP76zBGJboCLHM7RYrQjnPwbdIlrsAYOg3l9lJBiZIeDjGiW0+1RFbSEFpVsQu5obXHEYxjcIooZNWd7sISkl7yd+dsAzjLjPOS6+HHjG5CzfBNQiWycPUKnPk3donIYzSLCCJFpwtmw/mTeda0ki60RH5MtnOZr9GyZ6Il7ZsJlxVJ5tI6h1MO2FX1CLkUEN7henL2S29nMNd+YwYUynnme/u8z/M01pnVQKG2oBShr1AVi7SBDkg4iCMkoAi5bTdvrI45HlBEUTuVOysnZ++rT8vB2v7k/N552BWP9KWRQ1teQ591UO2q2hYXm51FezqhSKUEnLKF4UQdAsxRPsl6NCUBHF198pPzJtTlliszdF7iKD3t59oJ7bZHr7+RBQfVLYhTOhEtJ+ynJ0dX0jJvSX4IROjXE2JBX7mMYZMV+RlPI8tP2JE2t1ov15WSxjAfYPtuOcQqOC7DC8/KbRcRBHiZczAVsP0ixUoT531bm8prhSIJISiBnzcR4wSw2fWMWJ3VEcEJEhPu0ZxN2a9qLQaau24qdIM70zpin8B47wDFBrzrvTl+vgDNIt6qJpw8whcnoeuyMLUG63uF1GQjQNQhw8wO67bzLU06YEtOwa/HKUCutyPMJapA7NzGnes/D5kbrob0BcT8PgOt4eAay4hNcyB7u05qo//rRdetyRln2gD51V7AuNd6Udls9dVkuQfg316zLH2SDo72yK8wMV88VJs0D9jy0MhLEwmai+a7BmQWNgoc5howuMBBjOB4hO1l5kxS8gFsydU1o8hZ3BaRwSezQBrbcZZj0p0hm/abJ/fBDAvwhI1iN0E3IcfTTzVKawo8Tj+j2Ypq6kAZWND5HtCn/yGwwuO/6/iVUmrBAIEVLxyo2AVw9fDKPY/0sbrojzBhnyA6PYpzGWWoUoLdOV8nHIMVztQ1aRGPoXdu1GxlOKEy2ErJrzJktUR3mqy1FtOvK3+ODgSR1lR6W6DezrZaD5wNCuL0f9jh9mm43GUBHrIT8Gm/2EvV6qJUQfUeFynDamz/X61mWbolwO5/L6VopD4tvmwUYWH7bQB+Tb3Xhw2R/9YVvOF7+wrfjPMNmWvTQWUE6+fkttwrya9YXM6QvrTEAEqFnEElo/UirMB3y0wWQT1QG/C3DkiLpYITlPA00FmHFDY/kdNzn0NlqBEdyaaes7pZh7wvdt+br+vVDNMuaEfSAi9s6oU42O3o/3MJTY56HBQ+jWEoe07zRMw5efP3W94L6xEyIooEwEsS++rmhfYoMPBPPTlQa3Q9qZ0Ed+4Kb3uOpNP3ZlN4Edl1gGteZ2PZZB7B381iUz+cH1t8wFQOQHlnk4/zqfdd2v4YXWJzyIc+k7VzYscDLxAT/ukoQPEavOsfd1y7Fgrhl9qMCUdJ81NRHuecyaIYU4zQlCfrfx52rToR+54xEAcATlTkUcyaDcuL+1LeuV9ymY7tu0yjh9yzluNBUxZfpoA5DneMuPNJOJ9oIDfa8e6vlYnyIbo4OrydYja4Vv9Y0g7Pgz8+h5GPS85v0xkjgZua3fmT7JhyAMdgj5ZIm0E3+rQjdlCe8mW1IHnxTn5eQitKXZj+cfwDyq/LdkTdCNh/UP980zAN++OwIGw8ILDfUDxZx/ja/M6d/WFsm24WgYyymtvzt9Bi9+vn0+PWTz/Sb7VarvajVBPN8E17CHMRKPpZ5XAcIi3GyVxMnH4/34I5e9Fp2CBvtmujrfui0V0Jgnt1eA4nbe/srIXKvPU8wb0Ei99rbKyBSJoTUday63eOTk4uliKQsx4RbefGWHjvvB+hMQ3Ov5tafLXotKbPtvf2dtzuLqrMxHZM6Mw4+nn48Ma8oLrUozBg2MYNQySEunHnBB4UQFDJoj4WOhxQzDOXLWEo6BCwfuTUmCcVNeEUIf44eRmqc/uu0c94JDIQBjSlOzZvDf9kWkD7NIEK/avt7bFICMQMbDZjR5pR58erbxit+zDGXyqPDFli3TdUW3YPj+rbgR70Dw1WgDPFYQediuy1xGMjOd19rf7e18N5bMjeyIjXS5zRqJ8n2E11U3jU6K+czV7u1xTzoUO4uOoxYk+Nrk/hKy+Bcv8XdM37PakujAhcYJtgED0pU1pUvY83M2brzL6uqf+/s8DABtzGz6t7Fr8jELLjxSZC3+LxMzK3lN8qEfIuEwqOLL8VkQoXFkCjvG1cnFC6cTTiBcuYJZnXl3xp/FfAHYJqScd/IgZ6wctlpTZO6PsPmKouOJuQbVOp75oPfLsj7Bc5TiBbgVf9vzWk8ntm7YhbGMxndj3aig/1WK2q/2W3Pja1X5piOJzWGZTc7JhLr0PRMjgg0zkYXJ+aUog5DlgrUbELLRfgYCuhC+i8zfWcHlA2JmAjKlKlVAciWO63soPM9oIBPqH1y5wJxA9TGE9IEPnOdKTCTvh5TohG+I4jHcSYAV8c0vrg3/QqhTsJafAL78B5Qb2rhi5UywpqHWBUM0wEVhExBq2z1Uz7cMqAMTW1Lab22td1q72612lsQ66Js2LTppk0jnKYtBY+0zVqOybTi/betnXiXHGxvt/UPSYz3DvZ3ME529pNksPh+calnPTgqNZpA/pwsowm7F53T86vo5LeTxTm2hYl1s2mnWYbdDa/5AfDJRkzh508TYtBsUNfAHywojyXbR5jXDmggQZnx3goR6aBywtgtJiqpB4UioQ39z4rmjO39nbeL3u3Gcui9dBPxyhg4YCRqK0dOxylltws/j9bo08Mig2P7yuzghArAm7Q0l5Fj9McW5COrLXJ8NYLLRkDQ+AsEjUWOyxbURb/qzkSUjTOz2rjyugcnYn9VD86qpfi7N998UibfWdfNJ3h5Ca04vrN2m09I88X04Vioz+YTjP3V/Tdqb7A5J+8voBfHN+ms+YQ4ftDGHVUc/3C9NB9j8sdpolnF4Y/WPfMrPP5922Z+RTB/r36ZXxHG99Aos4qFdYfMb9ghs3IB1q0xv11rzMoF+MF7Yj7N8/fVDPMpXl6C6/39dMF8SpIvxu1eqP3lU5z91X73SvtezsvoC3Cyn9vw8inW/kYO83fZ4jJkREjVk4TMc9YedYVN6cosHCplSrtJQ9PowlbVgFPsW6NJOhyp0GoxlSuevFkONyEe0G43W3tX7TeH23uHu2+iVmshpNQh4VFM1bQuYOEjpzfLj9icKUHwAmhbQDNnimqPrBeX0kNXQvjVPW9aiLy4lKfsZ9+U1cydL2DpFdmqaT3OCwDPdrIy+VyoEeqAk7KAYjCcgC3Vo5LXtURH1lw77X6CNSqbLQuvgqG9rjNh6a7cOUeY4UXgNDXdgNxYshhKNA8J74WYVMXbhLMhVVli9FiKFfyjrIP+G22knG0couabnWi/vft2p9VAGylWG4dody/aa+0dtN+i/1lQJdVZMPlFEtF0ZeczqXmmWa6tPFS2VPWOpPpvQ4FZlmIRwsyrEZmiGGt/tM+zsAzxyHn1qtjgjgpTSxgTpl33hnlcTzkXNuDQ8DGDxHX68YO6jsceeMLY6w0Ue/O0WE6bFweayBVl0DhsDEWhQ8Idt+XUkz6XirNmssBLil7ACZcKp3Wd/M0LGN5o5tkyV1g0x1cBfhs6ReUZwzar1oOcjvHUwyHeMn7PoIMQ0qzARFyg308vQs8QIftYb3vM3NOEpFNTrumcScXdj2UhH+y2dhcIcWsBCzLUFleN6vUSZnhKuzY/L4DPGhBfk361hFeq188Z6ZMF97Q26v7krBZrY2QApJEe393PuSqSWTzSm/G0c94JPlfJob21tzpiCNYK3nqXEcZlr0NFgGszN+d0nvI0/6Fnt+fK02GKvbkQH/hD9kRvrna0He1EC+TIpfibmvwAQfAiLP4xFreUDSOV1lV3uHEl8GBAY3Sm2UQXgise8xQihNp6thTI6JpduriteRnMW/mFPf7QT+jXD6dXJ6Zd38+XJyfn5sfOx3cnl+bHy5PjUg8/+NICArL1Uz08TyhiVXvDzRq20PEy8BfVt9kiepfOwfpjb0RfP/YA7+AblS5w7Hd3F3DzbcJxXfGJ2U7GfuJN6XKdy8uWij97mUhHOFtANdfdKPiy0CM4pewWarZ4CABS1fHpyY3q3llsXW+QpLLlv7TVarXa2zsLqHVtWUhtawEqdlhHu3I/4pNDq4VZoEufIszYoH0syf4uIizmiVa2uRn6nguP+eGIRdyksXMm87u+SxSYrCcPoEIuyfBzRsTU/q5RbAQTczhDnCW+14WFUdEKB14vb9JJT//uJn+l5hO7iP1MuS0adMMz0Q9BYn5HhIOthO49ObSX75WiVdTlyc+9d6fnncv/NJx7pV6BrvH5XdY5anV++fzuqtPpdODf5j//WHbVDRLb1zrmuRTbyrU9cvW0WmfrldUb34zrcFq9nC68DIxFY8DUqr4JS2KXx5MMO0JSNkxzr8J+3u8Pk4n8Ssu3+3sD5Hzy20Xn/LjX/f21RbrJFyWngaq80gjwj2BcO6XF95cmdgwTwt7Vo3/8cnZ1CnPB2G44aH/iR7zDggJydkrYUI3MsPZpG3jNN7Me8/jXT5fHZi+f/Nz7rP9VID3YeMG+8i5dQmI6LlVmo1ckGqKbjfbGTQVs0+a/No4Or4XC14IkPaUm133KrsdTPJlE5IEs1CyzuNfK5Qar6cemMEuwSIpbwIDxWZ3igYJmmTa7ZAnGRnQ2j2glPHX6fUHujKMO96QratXzla6JD/88+7gED7dkWgMLH+gdaUJHfG2qQM0KHwDmYfnN/9P7q187lyfXefGSU/vnV9dHmRCEKfukcX06xkNi6ktOoCus3tmfYFJ5fU+ZJlRv2CUEUq4DWolE3udIS3lVt+mEC3lgzF4BVct7vbSMvMqokNX1Melnw+Ei0E1eaCHpdUXhTWaQtR5K22hxJmSMGSOiJxWeCyH0MWseotWa2M4vWyfHl7bLoQP5zKBz9CBL0ylKiDK9kcc4pTHlmQwLoKAn55fLs7ItvwBv1n9ehq9z433oVaBjaOkXmq3Ftui2rbpBLAB/BprpVaVKbC8Qz6uxZm3jyiL5Fxwwf4ca0/BoqiXxCbiFC50y182/Ff3/7L3rchs50iD6f54CwY44tuZQFEndfaLPhCzJX+uMbOtY8vS329+EBFaBJFrFQrmAksSO/bGvsa+3T7KBTACFupAqUqIky3ZMTItkFZCZSCQyE3nxbfGquW667tNMiVhMRCbXUa83X6eKD2mg8JOr41Ex70MxoTxe13TBRyHfaZ2GYYqfNR/hXzy52fJ+4MnNjvlYGnNCA++5SabYHf6pbU/zF/b5xA+2Yyd+ytLov2LiD/l3SJpbpwF4c/GpW5RW61ZgrF+zKf5yt93dX/cibCrOCYfH4uySpVEHKbYq0+YIRrcSKkujXJNrQWaByzVreYrwSUykmDASUAmmvzYaJ3RKwEw1xRdPzvSZsCFSdAEgS0TTvOALJQXUiK0MYtqtYwcxKIWYOw4xh30krG59hUNcoV/fhxAR0oCZdDwNZ8QVS2lETs5udtyYLA4iYWKdr/64woKE/74ib0+OLz6QLx8O3aD93c3+GsLkP5iHZ1rV3N4tuNqjpsqVBTd39wDYFW22SPnl+GbldV/z5teOwi591E2eF7R0LV9SbY54rTqB6ZoUjb2ojm671UmmCB8SrrBIqGxrBo6FIuyGpVM9BZYiLb1fGtxOm7CUi5BMMoktNAe2fBEL0fRhNjgqP9bh4QEjrSQetfKoYKg229Hfvd7qt5rbhimFytGrYrYzrBLrCSpTJAO21S9XnthSImmVFvbqlytMxFEkoWlejs0AvUyBcUA6i6IGCJf8D4+fWX8yxDqoX7+cYql1LLFhuk1PRQadr3OJOvUYBOr85hY5j8mVRe0KSi9BzRFVaBCZskDEUqUZ6IAQh+bXfYcaJjka6Pue6R0syrp3W1ubG1hB5B/ffjXf4+dflEiWWycrel7CWr35GrsLACcSgZ0lkQzuDXIaOtrViA4ek5ipW5Fek4mIuRIpj0cokZw2a8/lAdOiz7CIqQFIpb/oFLR7EomRCVTQr2rpOlQsxsrHviqJrn2qxuXO6Y5HJsywn3vNDUulbVZoAW1j92uGUY2xUFXJtBS76NFm/LwcJyVUSk94PXp5XDO8FVDmqFwiSBWBbVQQZJ579Mw4PjxgPElrSNtaFr6FL5/u78Chz4mZAG9tVTM2lrpf0tB/y9jK0hRAt4IJzIZyAUKAGP5iPLl1yLo9qVepxPiVs/EfcDaiAuZXIPdn6egzhhbV6Vjod0FapLnpj/muHuwdo4tjw3YK8w0y5Z5qe5MhsqjCuRGx5nxM2CRROTwAOj55Zd4uldcK+RAutRREAA2YumVeu1RozH8r0IRZVgFAa5ClLLxcrZl2Ac7T0ZiBHLaTwrmBE7eBMEnCnOyQ2QB/Kl1JFXRXbyx8GFy1raEQ/nVdCyoX+V+UxT7qwGYBQqZYOoGguyRlAZcsmtrOARGXikT8upBQKbPhkN+5EeGZt1rgv9vYwEfwiY5IR2sdcpFO7e1kkqTijk8w+5ZL6C3DJ0k0JYpeF8MujHqs1zyiAxZJvOXQOiEcorcsigD7i9Mjmcu4QHSy65qCTQ9Kude8I4MxW13o4zmMPlt0w3FatknwZvvqXa2yjPDOOJiXJIFl0VVuGzeJ7TSB0Z/oyPyW0Qh1MfMMmGDG2POiMaPIkgEzLdhdwBLUaMbC9GXDFkalbWXkQgd8JhQIygsdHMoQQPYGx7lQMMLvpvGoC1EF80UrdDBzQONY5MpoYQ+2PQrkrpAyQgMWidt6kVAvP4oyxqct+o2oVJ3J1IyAmwilCJXKKQzOT2NGKdi+gKs0uTpOylkGltmgrxmoVxBU7cKGz8HDg8VYPbY+Uz5GC71S+kxSKeVR7gSo2fhULpHSptldieQSkHqCw4INhybMRqvByDaGFm/ZxenRWhudVC76NV+F3HADodu2rUBAfPoSwdsyNW6R8ry5zyt/Uq8ZcMX3fabAeTLrOMlXotnBAt8vx2C28vSKGOurGf7h1snPUnAvoRTczypwc8jx3RaA+1n77ZFqv73Gsm8/aMW3n8Xe6ijx6tPWX3uJt1dd3e2VF3b7WdPtfpr8qOXcvu9Kbj+LuD1fEbef9duer37bD1a67ZVUbftZsO2xeeHF2MoPrNX2I5Rpe50V2n6s4mzfb102G4jfoRGnq3L/t7T6CxO8ZdJJWDu1afEvGawdJHxBuLZKM0DVZn/4+QEQfkexf1pwjcomLfi1TQyfa7Wjf9PMPe38V/z7GEJ9hfKHTNm3jEOvtqnI4M4rk4xQ8vHk4ssxObi4+L8O/wltsLwSOA4FD91OJfvgzR+k9Z/rByMWqxZpngXplmZlzYlgXXhYWZDcRIV7R8jBgco6kJhDBmxMb7hIfeq565aJCFnEjGpZIZ5P/HqK+4PWEN/ByMMqoc+729v9hcm7Qh2jVS5T8F2RGG6VK0Q+CD/wOFyYyklElRZWK5UxbpKnpbefqfUvP1Pr4PfzSqrUwV+ZzXuCP8nBkam1cniGf5zyODPpUxMafD7HPz9hpDF88If8PBzygJHNnW187pxS84bt3RffyxGWDfxx6zjC0bdeyJkJlxJyqy6vAfyRFmpsLMYjPm0suzx8TxYYbvaZ42AsYFBdBWuXU6VocN2ZcJUy6F1vB9gAGbmx8PKsNGtybO7tteq24IZ1K+ATcqENi45C3DEfsT8qfrgQIirs3pg03Ea1K6cxrC6YnqTpYiitCQVPow7AVHWL0CH/bS7CBS0NRmkXwo3IW3bXmc2n+IrcuDjodrv9DbJWpRj8UkeYVR7kfhK55dXGRPJpUmGQhxOpSqNizn6JTE8sabM0eknE8oevEq7pKEW6smAMfvCn2Zp2tgfvTjvQYuS0b8mNi153e7+G++D7GRR63D36KLlhcyTvXHV+4XWYoV2tbB0OxWRC4xAuQ84Ri3iEzaKTlNnr+OoaPZOAaEzPe+yXldGz+bszCCuzwVPJCghMR4Hhz/pQ+euP9TDydru9WaKj0+02vrmeQdwXKGZmS5IFF2i+qbbiBToTtyw9H7OoudZav0LPI2Qak9on7yzNfsWkXuz9+cvhFiNC/4viCrbbKV7XjVKRJe8IatWlNuya6Z1XVglC9VvaDouxXijkAUpTh0KSoQgySQR6X+34hCS2Li1XkkVDOJM4lFSDe4doSuiN4KEkPF4PWQLphjSaSi7zUHcE4a6z3d03o/qXdEMe2QBtU3lfI/W3GqKo1NSZ8ne0pVDAk/HKvPfnmC9qLg5sqQ2cEtkxzFL3NZbk8kldEZen55fHh0e/HV9+OT+4/P3k4rfLg+Pzy15/7/Lw/eElXqU33ahBxFmsOtV4+0dPsT7+uG5LVkpF43CdRiIuXrkKSBzNg0gQtkosVCYzYJ5JpuCPdcihlVjbllxVUboMxlCsRsK1UB5o4gaFlBxMasU7BKogc6XaUuXkpNNpfDM2C5IVkfgAakiKYYHW3uSmotiEXjOSJeULb0cMAHHeWiy1BnntHbsKVJlwnzy0ByuyQMSjHwaJcgXgqiZj/NHCRWm1if2ruSfSwDmmctyZhNsrWpjDgsSKR1oV5xAbZ7f9x6NtEvIRw6vMo+Mvbv3MBaOjnhg22TKlQCvM2BJQUkTjavxfftaeC76qC7TCsqsutgrGqKxE98PuzuHuh/7h9vb7D0e7R3vHe+/3Pmy9//D+Q/dw/7hxIwN/TeSY9p5tUc5/O+h996uyf7y5v3m0v9nb3Nvb2zvq7+31d3YO+0f7ve1+b+uod9Q7PDx+328cd1VanfyoeZb16W/v1K+Qo+FNfnf+8BXKR8WVepx9s7O3+2FnZ+egu711/KG3e9DdO+5/6Pd2+scH77cO3x92j/o728e9o9293e33x7tb7z9sHu72+ocH+/2jgw+NQ7wNjpiEsKJFq4mv8jIAbdl2gMB+AtWu9iAqVFD0Vqni8shTkr4IocjhAaQuncTDlGK1pCxl5ILRSZscHf7qsmWPDn9dIJfDTP4n3VzV8Y1CAIsM5QX+cV4JBc9DrWOPMWF8ShKWalbTLHZ+frqR692EjGkcyjG9rpZ/CrfY9qC3F+4MtreD3V5/t7+3v9nv94L9nQHtN++VY8jxGFkeR1SxDciE8HRkqNCGkzRJ+vB3Zk1+xJt+t99b7+r/XUBexLtud7HeDR6+D876WBThchLIfcj29ne7j4EsFIlKVxmPeaAV74BGkRaWMTn/dGJkqmJRJE0wD2QSYobMWEgFUkUJ/MY7K618gPBxpdgEXZ94f6iNKaJEh/yOlf8KseY3lEd0oEWCCzR3446YpnzC0Q6+CpkWcNj5yhSVrE8WW7iKpKU5ysrnlM8ViZxLYkeWeyXyZIq/gSg+EkE2cQXlH0kSyyzBZj+XaEuvKsjEmVVmmnrdoWDE4zdjFkWizmCZYcH3t3cu/+Pwo7bgN/e2tD2TP3h8eDTvUbcuraXsn591AZ6vLoC/BD96UYBaWnxnFQFqcHgJ6Q3fWTmAGiq+mPyGpWoB1CD03LkNKy8EcA/OLyDX4UmqANSQ4ZUmR/iYvrr8/zJyryf538fstWX+z8Dtx037n0GQHyvnfwYRvoeEfx/0n9n+T5jtXyD8z1T/p0v1LxD+lef51+P6fSX51+HwEkzg7yfDv46CL8b8XSq9vw6j57Z/HzW3/z4EX4Cxu2hifx1KP4Dh+l2m9K/SnpkRwJhbOLbN7IjfsNhck7TxQpMmScQDOoiqN9GSBUl/eydtbLkwqeggAsHeANOBEBGjcR1C7/EnMoxoAS1T/v3i9JzEbCQUx/uqWyq9Npxa8XQqlUppLKFRu4mTjQmLQR/Sn7M4ZlHj7RazO3VpQ2afdCldnO6AwVcANws75MzU1Ucbi/BiG4+Tg08Hefvkt36nIE5jCmHLVGotdcJiJTdUJNddYzWNwzqOO/OHzt1YTaJfaJTE6xbGdR7KtVKIlOnIkhsNkbhlKbQYqW1/tdHrNGa6lMlsslKG47IUXA0MZ+aFtjAOW81ed6jglLm0MZvhffrLjPg1sC0a8VtF6bkifmdBsiISrzLi11+LpdbgZUb8GjhfTcSvXabvOeLXX5PXEfH7nKvy2BG/pdV5JRG/DVcoH/U7jPg1OK404vd8odjeSkxvfkYgrBVT7klie83kf9LNlQWR1Qf34sSPFty7ub+1tdWjg53t3e0t1u93dwc91htsbe8ONne2es0LOCE9HusKVyo6SSqxriaw8yUE93r4Psqt7iIIP3lwr0F2tYGm541DSksCuUYAVIKOViYAfsZBPl8cpL8EP3ocZC0tvrM4yBocXsIl0HcWB1lDxRdzEbRUHGQNQs99D7TyOMh7cH4BV0NPEgdZQ4ZXep3kY/rq4iDLyL2eOEgfs9cWBzkDtx83DnIGQX6sOMgZRPge4iB90H/GQT5hHGSB8D/jIJ8uDrJA+FceB1mP6/cVB1mHw0swgb+fOMg6Cr4Y83epOMg6jJ7b/n3UOMj7EHwBxu6icZB1KP0Ahut3GQdZvKZ/bGg/oWpGEpq6qw173ZzQVJp4LfhepHzENfNhdFrNRU6n39g5btdixeGBnzT1I/4XCzGEDq6wXXQgHCI+mvehaAuPzkTQsV1CY1sbuQ6nKkYz8Clg88ao7DxXHW33j4TGoEfbhlGBwOr+WkyolAas8zcD+QE+nDJzYQX3+yLR5jmE6uEgFCNBKcTvtYnMgjGEAkDLCCYVxoZCWIEZV+80HjDYuZSEVNGBJva3jKXTDvJFzv3D4T7d29/rDXaDINymfm1XAPYJSVemDnzGsqsSayYnESPsBkgV8WvmU8bEow2YthyJEiOmKYIWkr25MyNTbT2njn5jGocRWlpuEh4rlq6buEkWWpLKMvm2BsP9/nBze3d3sLkV0h26GbD9/n7YZV22tbu587caDjXlYj0yWxyemNh22sbs6r/DsYTSmI/GmogAsn7vVqTXZMKozFJjUAIPO540/OuWwudie0aUiNztDrs7u5R2B3S/2x/sNiBqlqIcM3WJv345hY+z6xJ//XJqKw7DMRhq3RWKAKFNKDQo5pikqdJ2+tcvpxJvLc2TFilNl0HK6DWPRyQUt7FmJ0FkMGYT1iZY26lNEqrG5n1BbJTtQ0oN48Arkt9vjmB0yz5ZGuWyqFUsS9VyLEPISUykmDAImNZCS9N5QqdYSduEtZ+caSpsaNJqeoc8ZYGKpm3njqBF1NDM7uixwcehx25j2Li7cya34N0YCT2H/unKlNRCyvkQIkIaMHN1reGMuGIpjcjJ2c2OG5PFQSSMv/HqjytYu6t/X5G3J8cXH8iXD4du0P7uZn8NYfIfzF0n1v0CwcIDTZ9EwY4x+9CC60ZEsN+Uz8GagmAup8GGva+KI6AvgAYrJxzG3GopbSev0VrMlneoAS9ByG9oo/EiRkPcPcpbqovq6FwSiDqQTBGupZaJvG5rvoyF0sdFOoVy7WM4NYvvlwa30yYs5SIkk0wqGGSgTwQNHwuLJ0qewoAPDxhpJfHIq5qlX2919HfeXJ+EMkHLt1gzzuAFapCGMz/tLKSSvLVWrqJpZ/TXWhswd2MC2ahW6WM/ftAx1tvW6K9WG+HBEVprVX5KjDPLMtEwpaNJM5/1Ujx0JlJllHQjVgjcaOEm+OXKEzJKJK3Sel39coVXVKqgN1ugDXoOlyxqot3amBTz5RP3hDkZYq8NfbpAR1I+0VKRxnBETkUGhd1zmTf11loq4Ud58ZhcZWnU0eNdQdIUxJ6CzMR9yyV4MmOMdmIhWoGgjFpBBOqWG1KKLA3qM19sfk4ujd5tbW1uSEbTYPyPb7+a7/HzL0okhbWxwuHFr8+br/FEhFqVCnOJBmwriWQsLtDN0atm5/OYxNiCkUxEzJXQdg4KFDEARSh0p+WAacll2AJWMmVU+gtNIYeMRGIk2+48g2YHisXkTy2bnJ1hYolBASlsKJ8vJsywnHvNDUullrO3VDpA2wUFKRaqKliWYhE92oyfC9yTUCk92fPo6UZm+Lx1BBxgnRIMarw495bmUePSHJ78M4RolaYV6YIXiugHeWcs61o4RC5LK3BsbVUvHLa2NgtAgam5SrUDJjDMir8OGGof+ItJ26vDwfG7pmmJqSrnyz/gfEHdxPfA+LN0tMymRQUyFvpd2IlpfnOG0RQe7B2jfaZ4RQfzDTLlnmp7kyGyqN24ESGlgMaETRKVwwOg45NX5u2AxlqKuGtjDikLseJUMTJg6paxYgamuhWotJcOUUzKZCkLL1drb1x41mU+KYhaa0FpfJOE5Q2nswH+5C1jRVvzxsKHwcBrDYXwA49aekFa/hdlSYlan6FryBRLJzxmoT4/Ay5ZZPI9KOT+GXdFfmEts+GQ37kR4RlIc323sYGP4BMdkY7WOuQinZqCwzRJUnHHJxjCwaW2RSSfJNGUKLA4qwqhXsqIDlgktfSJQF2Cc+eWRRFgf3F6JHNBE4hOdt2qivByXJZzsYFhuyo+OIfRZ4tFOFjKyjUGCly9q1UPEd4ZR1QRM8tQq2RyNwnIcqMM43E/Jd8yGqGyYZ6JsRk9CKRcDtAostih857dBSzBI3sstBWjX8vi0GjWlV3cAVOdWueGZ1eUIQC3oklnR+kEvwfotHR+IGWbxsHMAY1jkStbhR3T9iiQW+BlhAYswvyV6gau3+1FieDTFt0VVKrOZGpGQJbHPU+lanXK7gEzSsE2A1ylufZxMsnypcwG/Y7MBr2CWGkXtmcOHkp3o8rbEPp8jBY6Q/TBoFLKo9xIrdmmVDa+BVUiuQQ0nkCYs+GQBZCCoDU7ZBSD/Vt2cXq01kZvyHUsbmNNwpzuuf0BQrFtvY8g3vyt7W2SGkO9PG/uXPGarQViAnzwfct8kPezxH2+Es0EP3xf4JtMsnSFEQZfzfA1CrcPAXpMjYvXfp7t4wUuBNe/8fRazZHwGJViLSDoQGQoOOFRtNWgYx27oc4UNl5FsPIcl5jmdpo/xvSGgSeGQcSHSD2XTqxSzqRRG2ESECsiBcswhtd4aCWFdUfTmFDIyTfWI54AnqCcmIV7ULe6MY1HTHZWKw385tfo7RXpNCc5qMITBlFwYjhLl6MxOT06ONOkPUBmPnJD+WKgebV0gzvkIK2QsYtJTs1LJhnw9KH6yNE9j9+PVOP5RuYKQFtrDK4ZRsV+PIgGLFXkmMdSMR4vShLg9WfjWZj9uZkWSbCyHsDVa0RXmAmwN/055VQqNtlIIqq0QF2YtxGLFR4s/iriZIuC6GXuPzqPfXV9ZE0NB2gwk2Kn0sIhNYSrfZSWMaGxiKcT/pfn+0Xyu49fJRtmkd6EV/qlDg+vNA/iB43glVM6AxEPcZ1pVDwY47BGj88kCxdn1zKjBnmax2Myqb1VkDXZv+frvfXt9X5vvd/tb/W39nv93b3d9f7Ofn+rv7/V3Vrvb2739rd3dvd21nvdBSpeGxSrXLwsko8vns/HIjU2oUhJJEbexW4drWiHLSmaUxGtLMvZlSjCcA49E6Gouime73Ojo5VQevNH65oPaEwvaTjhcatNWikDIzEeXeoBFyj88+q0JXeFbA2FH1IhzLF/oSphDuBPpbCGKD+wWlgmwveqGJbxeJGqYQ7kT+XwIcphTsdXrB7mSP7YCmJOhx9CRXwODcKPe3qJykHzoJtH0BwsdK9VKSji9yLP+yKIT3+U2/l/ntIzT2lLou/1AHYFz1/W2dpc0j3w4HVROj/CmapoOmLqh3RNGNRfqF/CQPdS9Y5ncEoYirxW5WNRCrxI9WRRJF6kL8JA+FPFeYgjwhDxe1WCmmP4wtSkJ3ZBGCK8Yl3JD5a6pCObyeOFTJH82waBUziGDZ+KIaUfSv5OGMbGUzJIxa2XXe1298WYTU02ihyLW6JPopjcsoFNDYbcFT0Uj0d5oL2pCZA5UG2Q+8NjnUKmp30qMW5mK68xPxuLmN1ju6wEoJykValDhzTlBaAWyM96PlUu9rjlssAtZQw/ir94FNGN7U6XvMU1+H/I4dlXsx7k8znp9S97GML5kQb6i/9cIwdJErHf2eCfXG3sdLc7vU5v28H59p+/XXw8beM7/8GCa7Fma5Bs9PqdLvkoBjxiG73t497WniHyxk53y3SMcqSWnSGd8GhVCTSfzwmOT97ayM+UhWOq2iRkA07jNhmmjA1k2Ca3PA7FrVyrEBCfrMDdLMPyZZren7HyRjwy6qE1B2I/Mdl1AEmhghcqwRXuQob5KP6kN6xMo2uWxmxVRlsFB5zNgY2FQ+jtrH2x1dnqdNd7vf461AnlQRn6F2jOPXiFbZkBb31nLel/lulhTYinWk87n9m7AYuVkG2SDbJYZfP2K01veWW/asBWZiZIDH6/MvOYygtgLVDFRiLlf+EToowkj5Vwi6vFsTmyBqmgIVQLZGmgFX+QY5xJz4b47B6XjAxFFIlbPbJpM5jnSkMm3FtXimjtHYl4nN21yYQGQNGY3+XJGoau1bIRn8/JVGRv3qT6hKeQlwEpACbtyCQDR1yqtknz9/I8sLSAGzIRSaZtqLBDziJGJSMRUySTkBFBBlNNqFjPQGOsDopTHR+etzVVk1QkQjLCvfxAGobQQrIa0w9oNtWUheystvpVhc+bCqxet9MrH6CrBdUrK3aPGqUPfU8Jv4nMgWnU73+dHnxqonjr56zKTdM8h9OYkFOy1+13et+IoqO3cg2TxxIaXDPlCh5JzP2gkvB4BKVMoNkG/gnjUylFwE3xPj1EbJO7wXYH415j7TYmdRWFzWR4JNpGk26nfMIc947Gvg6LlAUiDfVwPB5FBltFR5BmBtIhg3IQ0N3SLt4YCyBoQL+t83j9G2FxQBOZIZSybVwPdZCRQt66miY88PLdTLYFlHihLkFfsliKlLxlnVGH/HfGrtvkd54yOabp9Rpkn/MbFk2JM8/A0ZTSIRRcLlGCxzFLZ64qDkHwIYNcvsCSvLV5JGZU81sR/7UZSM5HD/Ez4y6K5Rz0UNr9zYrzaOrkL4+dhNK4xzW8ohkdmx0xSw5FRyOQBWbIzwPbjcxjbsu9HZ/LzSlQw3/2cTOk423ftQS1WtyuMHXIrEMq5DJIGTjAyjvMjAkQeOPNWpchT9ktjSLZJikwv2yjB4SGZEAjGgcslY9g/67MCQuInhyhYaFZJS9j7ValKsebnkUrNI8/J6aoJ2AArqdFcBCZkjy8p0C6Ow2yKGYpHXBXcNYeC5UfZp8P+ngoDNQgs43WTE0qaW6243TumHpQWhkqfCstCQGdqMTQKhBa/qfBmCuGbbwAQVWhF4UwJJnn+16A4miKrlhte93Jg7dD/5bkCKxgPdf51/PjNf0H9leI4EE3aP6CLcYoUvLB7PO1QqZq3uz6W0ajqRxlNA07+DcUCf92ywZjFiUbQ3EJlYGiDa0fRiwcMT30RgHBS6trM9kZq8kf/z8M5AArEiN/9t9rtXVhbI0rm4tYVSvf/NGyeC1wkxtE+nCxSeQr4hLoGVGYyNVZLVBBBiLNNdHC4uS+Hr+cDfQQgZbkwY2UG9Vauf86b1zY24P4hZnZFVp6X9QTEracOdmkO+hpBGemP23d2zM2RXDDOhOuUoYt4LVE2xjSb8Dc0S/BDbuEhNtLDzh5GaRMm1V/HEKdeTetL2k5wxP7+C4RUsuLw38d+xj+u7KqJ7G2oT6fE2xSQ/qdXr+z0/bLuRTJYWzBL2eHC3T9ZtCyYdXbwspO71YK9CO8POVyztJUt0TdEtXsieOmJFiZnqIxtxgbgfD25GjNFhcwfTgKRTnqjk6COd4dcuKnZZOseNFnJjCD2lvpKl3LZ0ZT1r8dU3XJ5aXeAjxcM7xe5vHcMVDm9ZOjf9es0To2Pup2u42b30BlT7a6suUHJGVYVm22gClo2UbaYKnVCVd8hEaSo4VdDMf9YWldyoSpX5FgxNcHPNbfglc4GPF/6D9+dXTc6fUWIKNmvMuVMr+xNUVKZEDjelatbYXV6/b2OoswhR4/ZmnnhsWhWFXB9wtTLGbWsQ4gEAShgtYFi+kgat7dKBAp6wzyvjjzkBlGgtYeo2/O9TBYMSKl8cjconY7Xa1/97qdrqn7ov8kA2ZvISZCKiLZDUv92oLvtWIpzYhC26haT5OSSTmBa1uQ2kkkuLJEmTCV8kCSt1QpGlyTGwjxyf2eWNbvjqtpmyQpv+ERGzFT9djEdSiWYknotTbhk4QGKh/Vj9LQY7hx9WujFIbVQ5l4K4DJdIKFQtQzlIAapcsq6MC666EIMo3yWkU/3e5sL7bELL7hqYj1aI1uP59orY99sO5bdBpPiStaCVxiVqhNllkhuNvnKdPjyxewRIpNEpG+pNW5MBDdtzBwhTihKkNCa5KG3Cuk1S6c13atgsfbFw0pvFqPOpjvn2xDlYL/IzeY337619FafthD1TEFHa0djWAZgD9pfM3jETiyW6fittUmrY8s5Nmkhdzc+o2Pxi1YAm2ckZu+XlQnPt2IwAmy7KaECMJ8LgVT5WNtdrqmetUUPI0hG/K4WJZXj5A/XFgjj4vgCS6JuI1ZiNoLjekIPVEfTr6cX3Q+pyPsoUPewhdaeJKv5+vY9D8W8XqSiiH3TC2ve02b3I6FFgZc2lraSpAxixKQ++B3lywA5tSaLcgJrX0lIvb6wSlGJ5LQIBUSFedbkUbhDBaNb8JOzKXqjMQNeCrWjSgCdq0KA7xCacaqZklWqF24Va/VMKDuk6YeCAp7CFJoBQf91yNHsyTlIuXKLARJ2YimEGPgiYDlKFhR4vU0gZv6Hq/k3XZ333dGQuOcw1JH+Ln3VVxqLSDCwwFvatAS0RvLuif1Zrkrte2Xhdacvt+SY7ePaEoiMRqZrhLk4vScaGGK9z0hH3E4CW3DvrwLn6MICzKldTwy4DFNudZjzjc+nnw8Ls4Wm6j3gQjhGThAaTSVUE4ZCrVbKAX4/a/dnv3dVnP3e6BhYKzEDhf67TZU8Ha3wRAReKV/gOZIVx0Yxow4pnLMpOW3o+Mv6yzWp0axC78WMy5m3bQd0G9eQfcXKI5fuIQZsPyy2d0O4u0WAqJf7sgx7W/vXK059I5vzKJSlQfi+v10K85me8OUX7/JdhEUSwps0YT08OtUGne0Xm3jwCJXKpIdr53UlWkfYUaEn4OIs1gZgj78roRGsIH1cQMZDauKF3U9uUzfPG9eUwfz7fnBp7UORvLpeSS5oelUnwhBaZuC2mBbhaIC4a0VuHwG0OtTb0+I4sQVzZtoaO4/+nROfIwJeauHsmWspVHXC4kirNoZ9M3fvarfjbUP08r7WTpRukaUy/Vwr2nVv3iLfof/c3SnlGXUmrenNHC/hI6Ui60eNqR0DSe1atUmn7/+WmpLDy0o56y02yvLrviL6UT5UTOFlgr/4ux2QSSeu/nkchv3JA4egOcL6EG5GNolzl4Q9VfaqzIW6hLa0DRAJ8zP26K9wCeMQIcfHowrSiG2AohEPGKmg3cIFa1vaMTDGp9rv7ve3V3v7ZDu5rve9rvN/f+7233XPN9HI4T3VKvECHwPTbDp7a939wCb3rut7rv+9mLYeO3kV90b/MA10LcBQ3jBryo998tYLtB928MnyNKbVW0iuADX4yMuJpyFRZF+IDA/eQ31vZbnnmVGsJu8JYt1XlTw1zZqst1vfEXgEYHdJSJu1nTK62tSwPXYDJF3vGAplB4vLhoGNzRDaGd7e3PXmachuytFmovgEuPLyhHozRGX/K8miz8LaXBR8L/cBYi3ljKhgTbQyICrqnbe727tNXezpJxGq23da5IkcSp7ZwpHjmPb+tMNXCYggKRiceD7s4fmJhtKuMOKJ2MaY9fdNuHKiw1HK1YZT4MAIynSigVceyQJhoy7ofOufhXCbm9/eP9+/3D36Pj9h+7+Xnf/qNc/PDxo3pffujNWLuhOiinThSbuFghfIvzOIHRyMmFwFeQXoccj2bpfyH8IckrjETlMp4kSJOKDlKbTDjlnzN2kjrgaZwOIbxqJiMajjZHYGERisDESvU5va0OmwUYAA2xomx7+rzMSv5xubu6un25uV3sSabV8e2d9ATFsG3A/i7kpnb05q2f6w1veO/yew5xc3pq0cL8Ec7IseqyjRm+emfbk+cWvuQ7aJqe/Fvr7e/Ym+vLBuny01X4xpmQB6UWxeG5bctamLCzcQ5B6AYZjCcfGaLxSI9A2xl+ppuNlE6EHHFSPCpttzgN6Xc/8jgwYXG3TOBiLFD+uBzbi0dznvMdnCiD8vzD2oe28ZM4k/bq7n7BXC3ATGkWmuSW4nzWotR5zSIkaC6k8QY10ohF3zSsTqsb2Ye/BGgD1vyOWpCyAW4t1uDnIX4RrGvjEi9lRNLbpWQX4NH4dxSfsL5t/Pxs8jIIvPTzhI4zLNFcHhdGRIoVhBWwW8xV+uKzjmxmou/WBsBsIBRhlKSwKTlaHXwPS6xXyn5uLFgy67JrOHVkTV6v7THZ4LJXnRL2XRuCWwHeJfZfw0G6LIBJZmO+AQ/3RxhGkZMIUDami9Zvio/kVg0GCwqsQcJjbIzQML+GBSzukfjJgUmKwmb9HCpjDSx0+oSOv7u2suym/3smEr9NBEPb6m7WSJWedEz02OTlygY6IiKWVYZxfyIFeQ3hIRKHPwhZUjVkH4bVUuBfeWexRO8xcFvFmt6BfNiDYfAAcEdxIC8NQEFsPhKLpdvHgmNBgzGN26eVyLwuGGcpPC28KhR8fdulJyWVBmTVeU3iSVICEfTCDmIEW54+UjXJdddnZC4PUzmzFXCiCa9hHRs4d2c81QgF/Az1Kn/dRxKD5Nwg5/E1LLDkWqbrEkybXj6x6gfOtOxk3Qw1wYDWhQn43XxysIC7xHITqYO7HOjJ6pKx/pZacM6bSEnTx2UCme1t6wVlLbzabdPnpTItY8gu5+Hz0+R35TdxqRWpCE6ym8I8KLAWVhsxXa8js84m4MwpB6Fie1prG32axjeHz3+wzlaFP4qHwudscftAO1Uo6j6H197XsbE7H48NzP1/b9uyUHRbIznQSdcxzmEBIU/Q1xyJez98s1SEWsxp1NtoZs5eyUGPPDjEQImI0brgcw5xWkMqUs0l1XiE7g4xH1SmrHOC0l1Zv76jX3W81A+fzOYEZ/AijekACEbLafTMPFqlSpoJxc2DsLFgsNJ46jr3OBiyNmYLgCcOh//S/qxk3/91po0XVMh+U+Pw5Xz7nL90rowtAL8uN5bVIRFgvwBYSCx5tEoGuuOqy66mymtNg2ZnOREi+nhzVT8STyjyFr5pPcXJWnQEcGQkNHo9s+YjVyURYOZ4eOJktiTVjspLp+PAJ7YB1efp6xv/9P/+XNDWwqiCZ0+bvDz7XvJ8vJzRJeDwyz7b+3lCoeDiZc3hCkyrIUNgUPZMvDm4PtnrgJYsgvejlge4gqwc8ZUnEAyqLFVPJg7k3H3fGpglZEonppORIefjE+bgzJgYX6zCLHh1lb+AZU9+j/y47sRvW3OeEfAh5qgp7LttG83nl0TSLFZ+wNXu0m1M0P9fP3Bc1EJgf8xPduVPqTuB8bPJIxy+7a2o6mLk7eXz8HPOhPI24jVlamcgHsLJCljLwalGhy98oo0Xq8sHvYwwyzwtfC1uj4sxFaEpM+mB46mo1lOcsFE8ozlr7UyzSSSkqpRb9hiWX7b/cFQlF8f9md8qfIhLXnK7TTImQS0h+y7fN/4e/kiPzy5T4zxHPI3ivQ7ZmKF9vNnC4IWddVZjnOuixLua63bcXG/nu7SWPCWQRQweaVziuHprG/qtGgBzTYGzKKI9poUiBCeoLaEwGjDCuxvlahCTMsCKKoqnKEssTOBCHOu8TrI/g7iUgByShKZ0wpVFOTc4krDVTYJJjB3z4Qn9smyR8AA0yrWikh1ASI5tOzvAJI7AID9uQHgNJlAWQIOVKSaBMPXFN9kiSijALmhrhjUgMQXburDETaDPRYT0PoBUwXwGgN9JVVnzrwbR2D1Be0v6jwYSjupgKRzKPs6Q+hKHiJY/rIczSGYlty8P19cspGYtbjBZDQMyuABjnLWGQpazpfi26Y2bA8/uYwUbMaXJLpdtkxqlFMzXW55WtaZSSWCjnkSjfALdMYZAxo6mCS96JiLkSaaskcWcIS/P0TIVk5vUlzGreLl5ZztZivIuIWSs5Z067onZSFAe1NvejTVJYnbIvdubRPudgn3msQ07iXyx9RyQkXFYRe6hLpIAWNMj5UwxMYT8bQezYqPOMiIZZoUISaaaIXghFI4sg5PMzqerGmodIJmvR8CJ0a+c+skckj8mEB6mQLBBxKGsssWDMGl8DZGnUqbwwS4efu/YHmMmnRzQgFNORr1SQXLUh11L/Z6yU/qgPXvhbXtVsNM/f3QSRQpukpRH5zXqIxNB1mkBVxKy81kMOUcBDInw8Aq+ufZYXF9i9pJn/5KwGywc4CE/O5kJ54kNVhMT6wdqF8SAPmCe28nZgQ0gws1aK6IaFhCc2bTOPD8hSsIwhNqTeOVDge1MPJKysyzIXQVjsVaR6EazkDiAyG7JJbOaFpYQSUJCw3LDL8yeMWXB9WZYES0B2QJS4ZrHVmSGdW3It62jMRCajKeHxjbhmoW02NcTJJRZezssW30KJOFvIl5yc4ZUSPGwPdVsP+ejTuakvVl0ICJpJaFXuaSpdQvGKhpKeT5gpewJqT4KlCIw/FdR+UN6xgiZGK+DfADNoJfCU1uJZHHoPw9dWy4vZnQJxEmYRC/HlunscaDby8MMLx8HJ8x1TNFLaJJMZ1OA1Rk8r4y2IIWyZq/9WzUUA/rLYeVOE7wyHAAdIXmevqF2Rx/SElJ0wMPvJ0WM4NWqHRu+e0ULB7ecpoR/NUsD3Zc3TBHhi3YRwvufMDly/BoVRW2cpk8ZihaL8VCoTycgmHNI9jJ1LDWeCfZqzDe5lt21ZHCaCx0q2YX9Lb39zNSZXExHC+RZddVr36LkP1dROjhyT+wQpkElvzkta5dnQf37uLB8gvQ/6VuEKAZ4w68kRygDG4vuPiyV3sz2VcLw2aWVJq01aobiNzYYdRngT0Cq8S+OpgVfbccEYxByPlSD2+RmHRhVmKIpVcHgWYFagURo+SbMqKWqOoEZDZsm8UTUFlhtXvzlvZE2gyzGXKq/dTKDepT5qZ9QrLYW9ztyO5nBQpoyjZh8IqUbvXYmTK1KwXgTOQn0ea83ZPfO3T/3+mT/Vglto9h6aLY/nzf+QbbTQPpq9kRqu0cytVL+XFhq1fjfN2k4LDT1rQ923o8pbyp2b2WRC4cnKyYm/NPTa5OOQ7/qgXFyAVs+R3AvvAEMRJLMgYCz0YqceImEXmHhIecRcwLqxbLw1Pzj7CJVEeFDRlWasdyU+f477U49urSmwlAvKMhTfiq8hidqxpTEePRC1mU0iIa6zpCGI+RgNWDInpjdRIahuNs+8WLfDY/sOcjM+i/N4xxG/YfEsUz5VCxoxznFlbX7soQJLSSgUj4KrOeuQaHqp++h+NLuZprEaM8UD7+K+de6+xBympkLUH6ueXjMWyJuwaNXcx7uNHODOKqXBNR2xy+Il0v3vQTGDh4m3Ez0Edt5EzoOS++BUhXNRpCFKPpc9VlxvOGm4BAdKUIoGyNGbRoJWLaVK6FCNeuqPM4jEoDIIlASczkIWf8ViemUw/GEvJ3zxuwT9DpZjE0MYhZiEpOL4UrGqdCjv1XlbbKZRX+NznxeF4AWO1noD5iE+m+nIPE1rjh7caLIap/5sGpJGMg8rY1tnpGJJOTriPuJV0JhPgXlwlYVfeao/RZbGbPpE3LOEd8qJOzoqU6V4ZUNHMpcxAL6WMQa/ZnzhLNU0FfeHLi1FknkoTpiUxWSSBqSUigbX97+S3xmljMVyLNRlyob3H/DTmE54UA0Qmof8LQ/VuPH+La3j7/pl6xSGm8UcZM3NCb+DPJC6iceMj8b1l4cNZv4N3r536tqZB5Eo2bLNZciBUikfZCbqE+0rDGwI+Q0PM1qAA2fqkM9xNIUYFwJnI56xElLeuXqDhhTU7hQxI7fsTUi+ZSzVHxeVRnqSheR4HW01oGDQ4BVJNM0j6aQ53yHNZ4DFRlmsOuRQpFhRGnv9AebE1iknXGvJNr8dO8vX63G27byphdxQo8uHrF/KAnrvi1PAZadKaeDSJmbHYiYs5Syuiepf4MLgYCBFlClmmxgaZQrSwfMZHHTGdi9iiP+wmecNs7XMY3pjeqKY2xq09WedKvPlwjAo74OGO8Se0RqxD7aQnOaRYRaRhPLY9pVY7TnrkgMeA49Tmo7Yc2MSBtHDMTmyO9KgAu0oWUhYHCK7PNGqFA2AJZE5FXR5yGfoks3gD6L686PByRVkUTbBfRvRqcgUkWM+VNixwJbf1xJhmEK55qqtb7b9JQith4giGMBICXRg8wkeZnn9bzgHaMpIymhkpE1hEKO0mXflkuLmITeVsdcryEOpXjMtGuJknvFUXDZbVM70MZ/Q9JoIfYpQ6L3llVKZpfql9drOvSw/EbFQIjYtZnmsbXIJNjkgi7Ie7iJm034W/UmzvVzx3zyOReZv5tLqlXFZsVmWq9x+35D73iqhcwtKKQvNXjZIFXY5cqZLjFYq8Z2vFxdnC4ZxmhHqaT7L9aqnWcx/lcfnkgauV62Oez8s5Xg1fnIIXLNBioY0VZdSpZfJMmbgQITTxmz8FHp4+dIR/4F27ts9FnlAwMXAuTK3EMJkn5Eo51GdD2hk+lLUW2gpC3nKAtXcT3MvArb0lxuaDEUUiVuElaZQ2xUKVrn+otq4OKVSEQ7tgM1VFseEdmUCvYcixcyHyoyaKE7Z4dDE/DaeZZHSkJWyGsls9ySZ7aJsRAu4xKUxCnY7uV3ZPCrQ7FZcvxrWX9TzX7rf0KNHdMpSksJ1g0p5ggFpTV3+NpxvuSPgf1To4txhA6ZuGYtNOerBVIFINfT4ljHoYazPwduUK8VibclVRst3Bzxqkk5QnhjIRdrxJoWOSyImNEoZrUgE4hVRqzZF8W5m7L9PQunDY5hPhjXDlVaoIMAOOFSk6ACgJEnZkN+1wc6uFQDEXkCGguFIWgxMc38EHqXgrwetIC5ehpaWSQAgaGRqAbJCpQH/LRhATWpY7XIhWd2U34S/SMV7MYp9uwqRqzWHDv5DMv7kBLJCTtBbnl0aMbAUJ8zlA2mCX03fK7wh8CVPjcSoSgqUIPdIjBdMZMvhl3g4PQ6ZMUbZ7i4r432Cu1Bj/0tN/BrhjseA3pveKQE314Vz00h/vR75ylU3bkn2f78rZzWnJa/ji2sEgkGlnN2w0CX5+SYacTZavc0tFF3SdTVHWvvg2VRSyyjakIwltrPtkHPNT6j5VobDOHiuOI3IxeGZt76EKsUmieqQ4zg0ejP0Esnld2W0kJtg+MIB8ZLPgpfCxcYgVoFvD+sFAd20oTGsgoVtYT2F3dtGDV7IME5EukhQUunxB1nG0PPbNvd+bLvAkX5ps8DspOX2fdVaqt33TCo6iLgcE1revQvo8XnI1UvZDSuws+ZQNNd78eqIJTn12B3W0C+R96UQykaHieBabvs3ip8P/3m+rc+Fu8ahtXaMeqLOigjzJiqJjnf3iI6H7tDT85e1QytKg787vZ15w6klm37IhNDOUcbcRvUGUaJA+pfCj+4ci/w4Rb1ULIa2J9ASfJEjLVo4SNFjjIWOMq8dxmUs1CXIhGK3MTI728gWdH9Hdjt7rtlzlXJ55XcekyG9wdIR5VawnbzR2VWHHNM04swmXBQ7lzmWeCMLXYjhzqrQt+w+TP1GcffhdH/K1SKIwsxXHXJK1SNi+ezyZUzjUI7p9aOdWBUJM+SxFi8aVDdZAyuuMvDLO9jK8yDLLLaeR0xBQkKlRbdfLX8eok7zqOugUQTkMap2ze+hYf95vTSstOXBxDcbTg4/njUUr+bNeoLO4MaTM8yrbiZVjYti4RzEIvd/Mq3ThkQjR46DsfhiBgYvyWMYAG5k8sVzq3xhibYiiyKgId88djLA/wkAAP//dLTXLw==" + return "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" } From 55ae27298639699d8b501aa42a3c02469270290b Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 11 Aug 2022 23:32:59 -0500 Subject: [PATCH 053/102] Tweaks --- .../monitors/wrappers/monitorstate/esloader_integration_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index ca81e68a6e9b..1b737f22faab 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -3,7 +3,6 @@ package monitorstate import ( "encoding/json" "fmt" - "github.com/elastic/go-elasticsearch/v8" "github.com/elastic/go-elasticsearch/v8/esapi" "github.com/gofrs/uuid" From ce39e3f439e67b3e12ffec876d8c6df1ae1d920c Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 12 Aug 2022 10:59:43 -0500 Subject: [PATCH 054/102] Tweaks for flapping --- heartbeat/monitors/wrappers/monitorstate/monitorstate.go | 5 ++++- .../monitors/wrappers/monitorstate/monitorstate_test.go | 2 ++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 85a68277eacd..cb0ff3512235 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -9,7 +9,7 @@ import ( // must occur for us to end a flapping state. FlappingThreshold-1 is the number // of consecutive checks that is insufficient to start a new state, but rather to // keep the current state and turn it into a flapping state. -const FlappingThreshold = 3 +const FlappingThreshold = 7 type StateStatus string @@ -96,6 +96,9 @@ func (s *State) recordCheck(monitorId string, newStatus StateStatus) { s.incrementCounters(newStatus) } else { // flap has ended oldState := *s + // Remove the flap history, or we'll create a linked list + // of our full history! + oldState.FlapHistory = nil *s = *newMonitorState(monitorId, newStatus) s.Ends = &oldState } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index dcf4ac0843fc..fce43344d841 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -22,6 +22,8 @@ func TestRecordingAndFlapping(t *testing.T) { // flipped us out of the threshold, which goes toward the new state. requireMSCounts(t, ms, 0, FlappingThreshold+1) require.Equal(t, priorChecksCount+FlappingThreshold-1, ms.Ends.Checks) + // We don't want to store the entire state history! + require.Empty(t, ms.Ends.FlapHistory) // Since we're now in a stable state a single up check should create a new state from a stable one ms.recordCheck(monitorID, StatusUp) From cfb33c0ce9d863abbe58af956fe3a3abf89edda5 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 12 Aug 2022 12:02:47 -0500 Subject: [PATCH 055/102] Fix infinite storage growth --- .../wrappers/monitorstate/monitorstate.go | 27 ++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index cb0ff3512235..3543968eb9ad 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -77,7 +77,7 @@ func (s *State) truncateFlapHistory() { // If the current state is continued it just updates counters and other record keeping, // if the state ends it actually swaps out the full value the state points to // and sets state.Ends. -func (s *State) recordCheck(monitorId string, newStatus StateStatus) { +func (s *State) recordCheck(monitorID string, newStatus StateStatus) { if s.Status == StatusFlapping { s.truncateFlapHistory() @@ -95,12 +95,7 @@ func (s *State) recordCheck(monitorId string, newStatus StateStatus) { s.FlapHistory = append(s.FlapHistory, newStatus) s.incrementCounters(newStatus) } else { // flap has ended - oldState := *s - // Remove the flap history, or we'll create a linked list - // of our full history! - oldState.FlapHistory = nil - *s = *newMonitorState(monitorId, newStatus) - s.Ends = &oldState + s.transitionTo(monitorID, newStatus) } } else if s.Status == newStatus { // stable state, status has not changed // The state is stable, no changes needed @@ -111,14 +106,22 @@ func (s *State) recordCheck(monitorId string, newStatus StateStatus) { s.Status = StatusFlapping s.FlapHistory = append(s.FlapHistory, newStatus) } else { - // state has changed, but we aren't flapping (yet), since we've been stable past the - // flapping threshold - oldState := *s - *s = *newMonitorState(monitorId, newStatus) - s.Ends = &oldState + s.transitionTo(monitorID, newStatus) } } +func (s *State) transitionTo(monitorID string, newStatus StateStatus) { + // state has changed, but we aren't flapping (yet), since we've been stable past the + // flapping threshold + oldState := *s + *s = *newMonitorState(monitorID, newStatus) + // We don't need to retain extra data when transitioning + s.Ends.FlapHistory = nil + // W edon't want an infinite linked list! + s.Ends.Ends = nil + s.Ends = &oldState +} + // copy returns a threadsafe copy since the instance used in the tracker is frequently mutated func (s *State) copy() *State { copied := *s From 6a2e430a7ee986afcfe5dfff196f8ad0feacc0c1 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 12 Aug 2022 12:18:02 -0500 Subject: [PATCH 056/102] Fix infinite storage growth --- heartbeat/monitors/wrappers/monitorstate/monitorstate.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 3543968eb9ad..d358f799285c 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -116,9 +116,9 @@ func (s *State) transitionTo(monitorID string, newStatus StateStatus) { oldState := *s *s = *newMonitorState(monitorID, newStatus) // We don't need to retain extra data when transitioning - s.Ends.FlapHistory = nil + oldState.FlapHistory = nil // W edon't want an infinite linked list! - s.Ends.Ends = nil + oldState.Ends = nil s.Ends = &oldState } From 372281d1442cb8a7b532f90d7b8171f1ee66dfc8 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 12 Aug 2022 12:59:15 -0500 Subject: [PATCH 057/102] Add tests for transitions --- .../monitorstate/esloader_integration_test.go | 2 +- .../wrappers/monitorstate/monitorstate.go | 11 ++++++++--- .../wrappers/monitorstate/monitorstate_test.go | 18 +++++++++++++++++- .../monitors/wrappers/monitorstate/tracker.go | 2 +- 4 files changed, 27 insertions(+), 6 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 1b737f22faab..198053762f2c 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -91,7 +91,7 @@ func (etc *esTestContext) createTestMonitorStateInES(t *testing.T, s StateStatus mUUID, _ := uuid.NewV4() mID := mUUID.String() mType := "testtyp" - initState := newMonitorState(mID, s) + initState := newMonitorState(mID, s, 0) etc.setInitialState(t, mType, mID, initState) return mID } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index d358f799285c..6295562009d2 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -19,13 +19,17 @@ const ( StatusFlapping StateStatus = "flap" ) -func newMonitorState(monitorId string, status StateStatus) *State { +func newMonitorState(monitorId string, status StateStatus, ctr int) *State { now := time.Now() ms := &State{ - ID: fmt.Sprintf("%s-%x", monitorId, now.UnixMilli()), + // ID is unique and sortable by time for easier aggregations + // Note that we add an incrementing counter to help with the fact that + // millisecond res isn't quite enough for uniqueness (esp. in tests) + ID: fmt.Sprintf("%s-%x-%x", monitorId, now.UnixMilli(), ctr), StartedAt: now, DurationMs: 0, Status: status, + ctr: ctr + 1, } ms.recordCheck(monitorId, status) @@ -46,6 +50,7 @@ type State struct { FlapHistory []StateStatus `json:"flap_history"` // Ends is a pointer to the prior state if this is the start of a new state Ends *State `json:"ends"` + ctr int } func (s *State) incrementCounters(status StateStatus) { @@ -114,7 +119,7 @@ func (s *State) transitionTo(monitorID string, newStatus StateStatus) { // state has changed, but we aren't flapping (yet), since we've been stable past the // flapping threshold oldState := *s - *s = *newMonitorState(monitorID, newStatus) + *s = *newMonitorState(monitorID, newStatus, s.ctr) // We don't need to retain extra data when transitioning oldState.FlapHistory = nil // W edon't want an infinite linked list! diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index fce43344d841..c1f872023053 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -7,7 +7,7 @@ import ( func TestRecordingAndFlapping(t *testing.T) { monitorID := "test" - ms := newMonitorState(monitorID, StatusUp) + ms := newMonitorState(monitorID, StatusUp, 0) recordFlappingSeries(monitorID, ms) require.Equal(t, StatusFlapping, ms.Status) require.Equal(t, FlappingThreshold+1, ms.Checks) @@ -48,3 +48,19 @@ func recordStableSeries(monitorID string, ms *State, count int, s StateStatus) { ms.recordCheck(monitorID, s) } } + +func TestTransitionTo(t *testing.T) { + id := "mymonitor" + s := newMonitorState(id, StatusUp, 0) + first := *s + s.transitionTo(id, StatusDown) + second := *s + s.transitionTo(id, StatusUp) + + require.NotEqual(t, s.ID, second.ID) + require.NotEqual(t, s.ID, first) + + require.Equal(t, second.ID, s.Ends.ID) + // Ensure No infinite storage of states + require.Nil(t, s.Ends.Ends) +} diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 62c4ec437b63..3e08e98a850e 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -42,7 +42,7 @@ func (t *Tracker) RecordStatus(monitorID string, newStatus StateStatus) (ms *Sta state := t.getCurrentState(monitorID) if state == nil { - state = newMonitorState(monitorID, newStatus) + state = newMonitorState(monitorID, newStatus, 0) t.states[monitorID] = state } else { state.recordCheck(monitorID, newStatus) From 4eff88d9f5d8ead9691205b2d6729b83b64e768e Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 12 Aug 2022 13:18:50 -0500 Subject: [PATCH 058/102] FMT --- heartbeat/beater/heartbeat.go | 5 ++-- heartbeat/esutil/esutil.go | 17 ++++++++++++ .../wrappers/monitorstate/esloader.go | 17 ++++++++++++ .../monitorstate/esloader_integration_test.go | 27 ++++++++++++++++--- .../wrappers/monitorstate/monitorstate.go | 17 ++++++++++++ .../monitorstate/monitorstate_test.go | 20 +++++++++++++- .../monitors/wrappers/monitorstate/tracker.go | 17 ++++++++++++ .../wrappers/monitorstate/tracker_test.go | 20 +++++++++++++- .../wrappers/monitorstate/util_test.go | 20 +++++++++++++- .../scenarios/es_integration_test.go | 4 +++ 10 files changed, 155 insertions(+), 9 deletions(-) diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index a722e047d976..9af62462975f 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -21,11 +21,12 @@ import ( "errors" "fmt" + "syscall" + "time" + conf "github.com/elastic/elastic-agent-libs/config" "github.com/elastic/elastic-agent-libs/logp" "github.com/elastic/go-elasticsearch/v8" - "syscall" - "time" "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/hbregistry" diff --git a/heartbeat/esutil/esutil.go b/heartbeat/esutil/esutil.go index fdab99f618c3..052cf1dfcdaa 100644 --- a/heartbeat/esutil/esutil.go +++ b/heartbeat/esutil/esutil.go @@ -1,3 +1,20 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package esutil import ( diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader.go b/heartbeat/monitors/wrappers/monitorstate/esloader.go index ec73fc4270ce..0f68e6d302b8 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader.go @@ -1,3 +1,20 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 198053762f2c..50e12f11591a 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -1,15 +1,34 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( "encoding/json" "fmt" - "github.com/elastic/go-elasticsearch/v8" - "github.com/elastic/go-elasticsearch/v8/esapi" - "github.com/gofrs/uuid" - "github.com/stretchr/testify/require" "testing" "time" + "github.com/gofrs/uuid" + "github.com/stretchr/testify/require" + + "github.com/elastic/go-elasticsearch/v8" + "github.com/elastic/go-elasticsearch/v8/esapi" + "github.com/elastic/beats/v7/heartbeat/esutil" ) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 6295562009d2..76b8709fd5b5 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -1,3 +1,20 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index c1f872023053..8ccdf351ad76 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -1,8 +1,26 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( - "github.com/stretchr/testify/require" "testing" + + "github.com/stretchr/testify/require" ) func TestRecordingAndFlapping(t *testing.T) { diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 3e08e98a850e..82887e568a7f 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -1,3 +1,20 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index 15fb15cd8a57..152535a35ddb 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -1,8 +1,26 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( - "github.com/stretchr/testify/require" "testing" + + "github.com/stretchr/testify/require" ) func TestTrackerRecord(t *testing.T) { diff --git a/heartbeat/monitors/wrappers/monitorstate/util_test.go b/heartbeat/monitors/wrappers/monitorstate/util_test.go index decff7a3552f..09e5d3263557 100644 --- a/heartbeat/monitors/wrappers/monitorstate/util_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/util_test.go @@ -1,8 +1,26 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( - "github.com/stretchr/testify/require" "testing" + + "github.com/stretchr/testify/require" ) func requireMSStatusCount(t *testing.T, ms *State, status StateStatus, count int) { diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go index eef25fb26860..0146e73b367a 100644 --- a/x-pack/heartbeat/scenarios/es_integration_test.go +++ b/x-pack/heartbeat/scenarios/es_integration_test.go @@ -1,3 +1,7 @@ +// 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 scenarios import ( From 426235239a0593872526b5592da68693071abf08 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 12 Aug 2022 13:42:01 -0500 Subject: [PATCH 059/102] FMT --- heartbeat/esutil/esutil.go | 2 +- heartbeat/hbtest/hbtestutil.go | 11 +++-- heartbeat/hbtestllext/isdefs.go | 10 +++++ .../monitorstate/esloader_integration_test.go | 1 + .../wrappers/monitorstate/tracker_test.go | 2 +- heartbeat/monitors/wrappers/wrappers_test.go | 43 +++++++++++++------ 6 files changed, 49 insertions(+), 20 deletions(-) diff --git a/heartbeat/esutil/esutil.go b/heartbeat/esutil/esutil.go index 052cf1dfcdaa..619421f68e92 100644 --- a/heartbeat/esutil/esutil.go +++ b/heartbeat/esutil/esutil.go @@ -57,7 +57,7 @@ func CheckRetResp(r *esapi.Response, argErr error) (body []byte, err error) { buf := new(bytes.Buffer) _, err = buf.ReadFrom(r.Body) if err != nil { - return nil, fmt.Errorf("", err) + return nil, fmt.Errorf("", err) } if r.StatusCode >= 300 { diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index 84202ca11635..e3c2bbef7c18 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -35,18 +35,20 @@ import ( "testing" "time" - "github.com/elastic/beats/v7/heartbeat/monitors/active/dialchain/tlsmeta" "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/monitors/active/dialchain/tlsmeta" + "github.com/elastic/beats/v7/heartbeat/hbtestllext" "github.com/stretchr/testify/require" - "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" - "github.com/elastic/beats/v7/libbeat/common/x509util" "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/validator" + + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" + "github.com/elastic/beats/v7/libbeat/common/x509util" ) // HelloWorldBody is the body of the HelloWorldHandler. @@ -194,13 +196,14 @@ func BaseChecks(ip string, status string, typ string) validator.Validator { ) } -// SummaryChecks validates the "summary" field and its subfields. +// SummaryChecks validates the "summary" + "state" fields func SummaryChecks(up int, down int) validator.Validator { return lookslike.MustCompile(map[string]interface{}{ "summary": map[string]interface{}{ "up": uint16(up), "down": uint16(down), }, + "state": hbtestllext.IsMonitorState, }) } diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go index 9e029cca885d..875ebe35e7c9 100644 --- a/heartbeat/hbtestllext/isdefs.go +++ b/heartbeat/hbtestllext/isdefs.go @@ -23,6 +23,8 @@ import ( "github.com/elastic/go-lookslike/isdef" "github.com/elastic/go-lookslike/llpath" "github.com/elastic/go-lookslike/llresult" + + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" ) // IsTime checks that the value is a time.Time instance. @@ -49,3 +51,11 @@ var IsUint16 = isdef.Is("positiveUInt16", func(path llpath.Path, v interface{}) } return llresult.ValidResult(path) }) + +var IsMonitorState = isdef.Is("isState", func(path llpath.Path, v interface{}) *llresult.Results { + _, ok := v.(monitorstate.State) + if !ok { + return llresult.SimpleResult(path, false, "expected a monitorstate.State") + } + return llresult.ValidResult(path) +}) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go index 50e12f11591a..ffa850bba224 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go @@ -132,6 +132,7 @@ func (etc *esTestContext) setInitialState(t *testing.T, typ string, monitorID st Monitor: Mon{Id: monitorID, Type: typ}, State: ms, }) + require.NoError(t, err) _, err = esutil.CheckRetResp(etc.esc.Index(idx, reqBodyRdr, func(request *esapi.IndexRequest) { // Refresh the index since we tend to re-query immediately, otherwise this would miss diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index 152535a35ddb..a39c8e7657fb 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -34,7 +34,7 @@ func TestTrackerRecord(t *testing.T) { ms = mst.RecordStatus(monId, StatusUp) } require.Equal(t, StatusUp, ms.Status) - requireMSCounts(t, ms, 4, 0) + requireMSCounts(t, ms, FlappingThreshold+1, 0) ms = mst.RecordStatus(monId, StatusDown) require.Equal(t, StatusDown, ms.Status) diff --git a/heartbeat/monitors/wrappers/wrappers_test.go b/heartbeat/monitors/wrappers/wrappers_test.go index 0bbe5d81ed3b..2528514d067d 100644 --- a/heartbeat/monitors/wrappers/wrappers_test.go +++ b/heartbeat/monitors/wrappers/wrappers_test.go @@ -122,6 +122,7 @@ func TestSimpleJob(t *testing.T) { }, }), hbtestllext.MonitorTimespanValidator, + stateValidator(), summaryValidator(1, 0), )}, nil, @@ -194,6 +195,7 @@ func TestAdditionalStdFields(t *testing.T) { "check_group": isdef.IsString, }, }), + stateValidator(), hbtestllext.MonitorTimespanValidator, summaryValidator(1, 0), )}, @@ -211,6 +213,7 @@ func TestErrorJob(t *testing.T) { } errorJobValidator := lookslike.Compose( + stateValidator(), lookslike.MustCompile(map[string]interface{}{"error": map[string]interface{}{"message": "myerror", "type": "io"}}), lookslike.MustCompile(map[string]interface{}{ "monitor": map[string]interface{}{ @@ -255,6 +258,7 @@ func TestMultiJobNoConts(t *testing.T) { "check_group": uniqScope.IsUniqueTo("check_group"), }, }), + stateValidator(), hbtestllext.MonitorTimespanValidator, summaryValidator(1, 0), ) @@ -302,6 +306,7 @@ func TestMultiJobConts(t *testing.T) { "status": "up", "check_group": uniqScope.IsUniqueTo(u), }, + "state": isdef.Optional(hbtestllext.IsMonitorState), }), hbtestllext.MonitorTimespanValidator, ) @@ -361,6 +366,7 @@ func TestMultiJobContsCancelledEvents(t *testing.T) { "status": "up", "check_group": uniqScope.IsUniqueTo(u), }, + "state": isdef.Optional(hbtestllext.IsMonitorState), }), hbtestllext.MonitorTimespanValidator, ) @@ -412,6 +418,12 @@ func urlValidator(t *testing.T, u string) validator.Validator { return lookslike.MustCompile(map[string]interface{}{"url": map[string]interface{}(URLFields(parsed))}) } +func stateValidator() validator.Validator { + return lookslike.MustCompile(map[string]interface{}{ + "state": hbtestllext.IsMonitorState, + }) +} + // This duplicates hbtest.SummaryChecks to avoid an import cycle. // It could be refactored out, but it just isn't worth it. func summaryValidator(up int, down int) validator.Validator { @@ -596,21 +608,24 @@ func TestProjectBrowserJob(t *testing.T) { urlStr := "http://foo.com" urlU, _ := url.Parse(urlStr) - expectedMonFields := lookslike.MustCompile(map[string]interface{}{ - "monitor": map[string]interface{}{ - "type": "browser", - "id": projectMonitorValues.id, - "name": projectMonitorValues.name, - "duration": mapstr.M{"us": time.Second.Microseconds()}, - "origin": "my-origin", - "check_group": projectMonitorValues.checkGroup, - "timespan": mapstr.M{ - "gte": hbtestllext.IsTime, - "lt": hbtestllext.IsTime, + expectedMonFields := lookslike.Compose( + lookslike.MustCompile(map[string]interface{}{ + "state": isdef.Optional(hbtestllext.IsMonitorState), + "monitor": map[string]interface{}{ + "type": "browser", + "id": projectMonitorValues.id, + "name": projectMonitorValues.name, + "duration": mapstr.M{"us": time.Second.Microseconds()}, + "origin": "my-origin", + "check_group": projectMonitorValues.checkGroup, + "timespan": mapstr.M{ + "gte": hbtestllext.IsTime, + "lt": hbtestllext.IsTime, + }, }, - }, - "url": URLFields(urlU), - }) + "url": URLFields(urlU), + }), + ) testCommonWrap(t, testDef{ "simple", // has no summary fields! From 972353250c6a900b48072ae24f2012fa913368ca Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 15 Aug 2022 13:17:41 -0500 Subject: [PATCH 060/102] Update and refine ECS types / checks to more precisely test ECS errors --- heartbeat/ecserr/ecserr.go | 31 ++++++++++++------- heartbeat/hbtest/hbtestutil.go | 15 ++++++--- heartbeat/hbtestllext/isdefs.go | 28 +++++++++++++++++ heartbeat/monitors/active/http/check.go | 2 +- heartbeat/monitors/active/http/http_test.go | 3 +- .../monitors/browser/synthexec/synthtypes.go | 15 ++++----- .../browser/synthexec/synthtypes_test.go | 21 +++++++------ 7 files changed, 80 insertions(+), 35 deletions(-) diff --git a/heartbeat/ecserr/ecserr.go b/heartbeat/ecserr/ecserr.go index 13b2aed14741..2db405155578 100644 --- a/heartbeat/ecserr/ecserr.go +++ b/heartbeat/ecserr/ecserr.go @@ -19,13 +19,18 @@ package ecserr import ( "fmt" + "net/http" "time" ) +type EType string + +type ECode string + // ECSErr represents an error per the ECS specification type ECSErr struct { - Type string `json:"type"` - Code string `json:"code"` + Type EType `json:"type"` + Code ECode `json:"code"` Message string `json:"message"` // StackTrace is optional, since it's more rare, it's nicer to // have it JSON serialize to null. @@ -34,11 +39,11 @@ type ECSErr struct { StackTrace *string `json:"stack_trace"` } -func NewECSErr(typ string, code string, message string) *ECSErr { +func NewECSErr(typ EType, code ECode, message string) *ECSErr { return NewECSErrWithStack(typ, code, message, nil) } -func NewECSErrWithStack(typ string, code string, message string, stackTrace *string) *ECSErr { +func NewECSErrWithStack(typ EType, code ECode, message string, stackTrace *string) *ECSErr { return &ECSErr{ Type: typ, Code: code, @@ -61,14 +66,14 @@ func (e *ECSErr) String() string { } const ( - ETYPE_IO = "io" + TYPE_IO = "io" ) type SynthErrType string func NewBadCmdStatusErr(exitCode int, cmd string) *ECSErr { return NewECSErr( - ETYPE_IO, + TYPE_IO, "BAD_CMD_STATUS", fmt.Sprintf("command '%s' exited unexpectedly with code: %d", cmd, exitCode), ) @@ -76,7 +81,7 @@ func NewBadCmdStatusErr(exitCode int, cmd string) *ECSErr { func NewCmdTimeoutStatusErr(timeout time.Duration, cmd string) *ECSErr { return NewECSErr( - ETYPE_IO, + TYPE_IO, "CMD_TIMEOUT", fmt.Sprintf("command '%s' did not exit before extended timeout: %s", cmd, timeout.String()), ) @@ -84,16 +89,18 @@ func NewCmdTimeoutStatusErr(timeout time.Duration, cmd string) *ECSErr { func NewSyntheticsCmdCouldNotStartErr(reason error) *ECSErr { return NewECSErr( - ETYPE_IO, + TYPE_IO, "SYNTHETICS_CMD_COULD_NOT_START", fmt.Sprintf("could not start command not found: %s", reason), ) } -func NewBadHTTPStatusErr(code int, statusText string) *ECSErr { +const CODE_BAD_HTTP_STATUS = "BAD_HTTP_STATUS" + +func NewBadHTTPStatusErr(httpCode int) *ECSErr { return NewECSErr( - ETYPE_IO, - "BAD_HTTP_STATUS", - fmt.Sprintf("Bad HTTP status %s encountered", statusText), + TYPE_IO, + CODE_BAD_HTTP_STATUS, + fmt.Sprintf("Bad HTTP status %s encountered", http.StatusText(httpCode)), ) } diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index e3c2bbef7c18..38896a82c9f7 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -37,6 +37,7 @@ import ( "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/monitors/active/dialchain/tlsmeta" "github.com/elastic/beats/v7/heartbeat/hbtestllext" @@ -65,7 +66,7 @@ func HelloWorldHandler(status int) http.HandlerFunc { w.WriteHeader(status) //nolint:errcheck // There are no new changes to this line but // linter has been activated in the meantime. We'll cleanup separately. - io.WriteString(w, HelloWorldBody) + _, _ = io.WriteString(w, HelloWorldBody) }, ) } @@ -84,7 +85,7 @@ func SizedResponseHandler(bytes int) http.HandlerFunc { w.WriteHeader(200) //nolint:errcheck // There are no new changes to this line but // linter has been activated in the meantime. We'll cleanup separately. - io.WriteString(w, body.String()) + _, _ = io.WriteString(w, body.String()) }, ) } @@ -98,7 +99,7 @@ func CustomResponseHandler(body []byte, status int, extraHeaders map[string]stri w.WriteHeader(status) //nolint:errcheck // There are no new changes to this line but // linter has been activated in the meantime. We'll cleanup separately. - w.Write(body) + _, _ = w.Write(body) }, ) } @@ -238,6 +239,12 @@ func URLChecks(t *testing.T, u *url.URL) validator.Validator { }) } +func ECSErrChecks(eErr *ecserr.ECSErr) validator.Validator { + return lookslike.MustCompile(map[string]interface{}{ + "error": hbtestllext.IsECSErrExact(eErr), + }) +} + // ErrorChecks checks the standard heartbeat error hierarchy, which should // consist of a message (or a lookslike isdef that can match the message) and a type under the error key. // The message is checked only as a substring since exact string matches can be fragile due to platform differences. @@ -276,7 +283,7 @@ func CertToTempFile(t *testing.T, cert *x509.Certificate) *os.File { require.NoError(t, err) //nolint:errcheck // There are no new changes to this line but // linter has been activated in the meantime. We'll cleanup separately. - certFile.WriteString(x509util.CertToPEMString(cert)) + _, _ = certFile.WriteString(x509util.CertToPEMString(cert)) return certFile } diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go index 875ebe35e7c9..eb26a2cbec60 100644 --- a/heartbeat/hbtestllext/isdefs.go +++ b/heartbeat/hbtestllext/isdefs.go @@ -24,6 +24,7 @@ import ( "github.com/elastic/go-lookslike/llpath" "github.com/elastic/go-lookslike/llresult" + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" ) @@ -59,3 +60,30 @@ var IsMonitorState = isdef.Is("isState", func(path llpath.Path, v interface{}) * } return llresult.ValidResult(path) }) + +var IsECSErrExact = func(expectedErr *ecserr.ECSErr) isdef.IsDef { + return isdef.Is("matches ECS ERR", func(path llpath.Path, v interface{}) *llresult.Results { + // This conditional is a bit awkward, apparently there's a bug in lookslike where a pointer + // value is de-referenced, so a given *ecserr.ECSErr turns into an ecserr.ECSErr + var givenErr *ecserr.ECSErr + givenErrNoPtr, ok := v.(ecserr.ECSErr) + if !ok { + return llresult.SimpleResult(path, false, "ecserr.ECSErr expected, got %v", v) + } + givenErr = &givenErrNoPtr + + if expectedErr.Code != givenErr.Code { + return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", expectedErr.Code, expectedErr.Code) + } + + if expectedErr.Type != givenErr.Type { + return llresult.SimpleResult(path, false, "ECS error code does not match, expected %s, got %s", expectedErr.Type, givenErr.Type) + } + + if expectedErr.Message != givenErr.Message { + return llresult.SimpleResult(path, false, "ECS error message does not match, expected %s, got %s", expectedErr.Message, givenErr.Message) + } + + return llresult.ValidResult(path) + }) +} diff --git a/heartbeat/monitors/active/http/check.go b/heartbeat/monitors/active/http/check.go index 013ebb7711e3..36913fb130ef 100644 --- a/heartbeat/monitors/active/http/check.go +++ b/heartbeat/monitors/active/http/check.go @@ -121,7 +121,7 @@ func checkStatus(status []uint16) respValidator { func checkStatusOK(r *http.Response) error { if r.StatusCode >= 400 { - return ecserr.NewBadHTTPStatusErr(r.StatusCode, r.Status) + return ecserr.NewBadHTTPStatusErr(r.StatusCode) } return nil } diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 9f1f3aaef53a..e3d841b69386 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -48,6 +48,7 @@ import ( "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/hbtest" "github.com/elastic/beats/v7/heartbeat/hbtestllext" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" @@ -300,7 +301,7 @@ func TestDownStatuses(t *testing.T) { hbtest.RespondingTCPChecks(), hbtest.SummaryChecks(0, 1), respondingHTTPChecks(server.URL, "text/plain; charset=utf-8", status), - hbtest.ErrorChecks(fmt.Sprintf("%d", status), "validate"), + hbtest.ECSErrChecks(ecserr.NewBadHTTPStatusErr(status)), respondingHTTPBodyChecks("hello, world!"), )), event.Fields, diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go index 2619a6292d93..768f9cca7b7d 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes.go @@ -10,10 +10,11 @@ import ( "net/url" "time" - "github.com/elastic/beats/v7/heartbeat/ecserr" - "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" "github.com/elastic/elastic-agent-libs/logp" "github.com/elastic/elastic-agent-libs/mapstr" + + "github.com/elastic/beats/v7/heartbeat/ecserr" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" ) // These constants define all known synthetics event types @@ -93,7 +94,7 @@ func (se SynthEvent) ToMap() (m mapstr.M) { if se.URL != "" { u, e := url.Parse(se.URL) if e != nil { - logp.Warn("Could not parse synthetics URL '%s': %s", se.URL, e.Error()) + logp.L().Warn("Could not parse synthetics URL '%s': %s", se.URL, e.Error()) } else { _, _ = m.Put("url", wrappers.URLFields(u)) } @@ -147,8 +148,8 @@ func (se *SynthError) toECSErr() *ecserr.ECSErr { stack = &se.Stack } return ecserr.NewECSErrWithStack( - t, - se.Code, + ecserr.EType(t), + ecserr.ECode(se.Code), se.Message, stack, ) @@ -162,8 +163,8 @@ func ECSErrToSynthError(ee *ecserr.ECSErr) *SynthError { stack = *ee.StackTrace } return &SynthError{ - Type: ee.Type, - Code: ee.Code, + Type: string(ee.Type), + Code: string(ee.Code), Message: ee.Message, Stack: stack, } diff --git a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go index ae88310fb3b8..229908709dd2 100644 --- a/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go +++ b/x-pack/heartbeat/monitors/browser/synthexec/synthtypes_test.go @@ -10,12 +10,13 @@ import ( "testing" "time" - "github.com/elastic/beats/v7/heartbeat/ecserr" - "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/testslike" + "github.com/elastic/beats/v7/heartbeat/ecserr" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers" + "github.com/stretchr/testify/require" ) @@ -60,7 +61,7 @@ func TestToMap(t *testing.T) { { "root fields, step metadata", mapstr.M{ - "type": "step/start", + "type": StepStart, "package_version": "1.2.3", "journey": mapstr.M{"name": "MyJourney", "id": "MyJourney", "tags": []string{"foo"}}, "step": mapstr.M{"name": "MyStep", "status": "success", "index": 42, "duration": mapstr.M{"us": int64(1232131)}}, @@ -73,7 +74,7 @@ func TestToMap(t *testing.T) { }, mapstr.M{ "synthetics": mapstr.M{ - "type": "step/start", + "type": StepStart, "package_version": "1.2.3", "nested": "v1", "journey": mapstr.M{"name": "MyJourney", "id": "MyJourney", "tags": []string{"foo"}}, @@ -139,15 +140,15 @@ func TestToMap(t *testing.T) { } func TestSynthErrConversion(t *testing.T) { - name := "myname" + name := ecserr.EType("TEST_TYPE") message := "mymessage" stack := "mystack" - code := "mycode" + code := ecserr.ECode("TEST_CODE") t.Run("SynthErr -> ECS", func(t *testing.T) { se := &SynthError{ - Name: name, - Code: code, + Name: string(name), + Code: string(code), Message: message, Stack: stack, } @@ -162,8 +163,8 @@ func TestSynthErrConversion(t *testing.T) { t.Run("ECS Err -> SynthErr", func(t *testing.T) { ecse := ecserr.NewECSErrWithStack(name, code, message, &stack) se := ECSErrToSynthError(ecse) - require.Equal(t, name, se.Type) - require.Equal(t, code, se.Code) + require.Equal(t, name, ecserr.EType(se.Type)) + require.Equal(t, code, ecserr.ECode(se.Code)) require.Equal(t, message, se.Message) require.Equal(t, stack, se.Stack) }) From f22b06731acba0da6af46f7d41a5570a3a5e76df Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 15 Aug 2022 14:14:11 -0500 Subject: [PATCH 061/102] Fix state ends --- .../wrappers/monitorstate/monitorstate.go | 8 ++++++- .../monitorstate/monitorstate_test.go | 23 +++++++++++++++---- 2 files changed, 25 insertions(+), 6 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 76b8709fd5b5..f2e42b76a6ed 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -71,7 +71,7 @@ type State struct { } func (s *State) incrementCounters(status StateStatus) { - s.DurationMs = time.Until(s.StartedAt).Milliseconds() + s.DurationMs = time.Now().Sub(s.StartedAt).Milliseconds() s.Checks++ if status == StatusUp { s.Up++ @@ -130,6 +130,12 @@ func (s *State) recordCheck(monitorID string, newStatus StateStatus) { } else { s.transitionTo(monitorID, newStatus) } + + // Ensure that the ends field is set to nil + // It's only needed on transitions + if s.Checks > 1 { + s.Ends = nil + } } func (s *State) transitionTo(monitorID string, newStatus StateStatus) { diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index 8ccdf351ad76..7775878f7b7c 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -19,6 +19,7 @@ package monitorstate import ( "testing" + "time" "github.com/stretchr/testify/require" ) @@ -31,17 +32,13 @@ func TestRecordingAndFlapping(t *testing.T) { require.Equal(t, FlappingThreshold+1, ms.Checks) require.Equal(t, ms.Up+ms.Down, ms.Checks) - // Use double the flapping threshold so any transitions after this are stable - priorChecksCount := ms.Checks recordStableSeries(monitorID, ms, FlappingThreshold*2, StatusDown) require.Equal(t, StatusDown, ms.Status) // The count should be FlappingThreshold+1 since we used double the threshold before // This is because we have one full threshold of stable checks, as well as the final check that // flipped us out of the threshold, which goes toward the new state. requireMSCounts(t, ms, 0, FlappingThreshold+1) - require.Equal(t, priorChecksCount+FlappingThreshold-1, ms.Ends.Checks) - // We don't want to store the entire state history! - require.Empty(t, ms.Ends.FlapHistory) + require.Nil(t, ms.Ends, "expected nil ends after a stable series") // Since we're now in a stable state a single up check should create a new state from a stable one ms.recordCheck(monitorID, StatusUp) @@ -49,6 +46,16 @@ func TestRecordingAndFlapping(t *testing.T) { requireMSCounts(t, ms, 1, 0) } +func TestDuration(t *testing.T) { + monitorID := "test" + ms := newMonitorState(monitorID, StatusUp, 0) + ms.recordCheck(monitorID, StatusUp) + time.Sleep(time.Millisecond * 10) + ms.recordCheck(monitorID, StatusUp) + // Pretty forgiving upper bound to account for flaky CI + require.True(t, ms.DurationMs > 9 && ms.DurationMs < 300, "Expected duration to be ~10ms, got %d", ms.DurationMs) +} + // recordFlappingSeries is a helper that should always put the monitor into a flapping state. func recordFlappingSeries(monitorID string, ms *State) { for i := 0; i < FlappingThreshold; i++ { @@ -78,7 +85,13 @@ func TestTransitionTo(t *testing.T) { require.NotEqual(t, s.ID, second.ID) require.NotEqual(t, s.ID, first) + // Ensure ends is set require.Equal(t, second.ID, s.Ends.ID) + require.Equal(t, second.DurationMs, s.Ends.DurationMs) + require.Equal(t, second.StartedAt, s.Ends.StartedAt) + require.Equal(t, second.Checks, s.Ends.Checks) + require.Equal(t, second.Up, s.Ends.Up) + require.Equal(t, second.Down, s.Ends.Down) // Ensure No infinite storage of states require.Nil(t, s.Ends.Ends) } From c480df14f3031e5d5bb3b38e2adeb39df1b23603 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 15 Aug 2022 14:17:54 -0500 Subject: [PATCH 062/102] Fix test failures --- heartbeat/ecserr/ecserr_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/heartbeat/ecserr/ecserr_test.go b/heartbeat/ecserr/ecserr_test.go index c00e205860e9..0ce3c038d6c4 100644 --- a/heartbeat/ecserr/ecserr_test.go +++ b/heartbeat/ecserr/ecserr_test.go @@ -40,8 +40,8 @@ func TestEcsErrNewWithStack(t *testing.T) { require.Equal(t, message, eErr.Error()) require.Equal(t, message, e.Message) - require.Equal(t, typ, e.Type) - require.Equal(t, code, e.Code) + require.Equal(t, EType(typ), e.Type) + require.Equal(t, ECode(code), e.Code) require.Equal(t, stackTrace, *e.StackTrace) } @@ -49,6 +49,6 @@ func TestEcsErrNew(t *testing.T) { e := NewECSErr(typ, code, message) require.Equal(t, message, e.Message) - require.Equal(t, typ, e.Type) - require.Equal(t, code, e.Code) + require.Equal(t, EType(typ), e.Type) + require.Equal(t, ECode(code), e.Code) } From 75654066c5f21acd9cee50da69a9a1d0e1db3246 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 15 Aug 2022 15:46:58 -0500 Subject: [PATCH 063/102] Use error codes for most test situations --- heartbeat/ecserr/ecserr.go | 22 +++++++++++++-- heartbeat/hbtest/hbtestutil.go | 8 +++++- heartbeat/hbtestllext/isdefs.go | 28 +++++++++++++++++-- .../monitors/active/dialchain/dialers.go | 12 ++++---- heartbeat/monitors/active/http/http_test.go | 5 ++-- heartbeat/monitors/active/tcp/tcp_test.go | 14 ++++++---- 6 files changed, 68 insertions(+), 21 deletions(-) diff --git a/heartbeat/ecserr/ecserr.go b/heartbeat/ecserr/ecserr.go index 2db405155578..34cee65a96fc 100644 --- a/heartbeat/ecserr/ecserr.go +++ b/heartbeat/ecserr/ecserr.go @@ -95,12 +95,28 @@ func NewSyntheticsCmdCouldNotStartErr(reason error) *ECSErr { ) } -const CODE_BAD_HTTP_STATUS = "BAD_HTTP_STATUS" - func NewBadHTTPStatusErr(httpCode int) *ECSErr { return NewECSErr( TYPE_IO, - CODE_BAD_HTTP_STATUS, + "BAD_HTTP_STATUS", fmt.Sprintf("Bad HTTP status %s encountered", http.StatusText(httpCode)), ) } + +func NewDNSLookupFailedErr(host string, err error) *ECSErr { + return NewECSErr( + TYPE_IO, + "DNS_LOOKUP_FAILED", + fmt.Sprintf(`DNS lookup failure "%s": %s`, host, err.Error()), + ) +} + +const CODE_NET_COULD_NOT_CONNECT = "NET_COULD_NOT_CONNECT" + +func NewCouldNotConnectErr(host, port string, err error) *ECSErr { + return NewECSErr( + TYPE_IO, + CODE_NET_COULD_NOT_CONNECT, + fmt.Sprintf("Could not connect to '%s:%s' with error: %s", host, port, err), + ) +} diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index 38896a82c9f7..7760f2739b37 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -239,9 +239,15 @@ func URLChecks(t *testing.T, u *url.URL) validator.Validator { }) } +func ECSErrCodeChecks(ecode ecserr.ECode, messageContains string) validator.Validator { + return lookslike.MustCompile(map[string]interface{}{ + "error": hbtestllext.IsECSErrMatchingCode(ecode, messageContains), + }) +} + func ECSErrChecks(eErr *ecserr.ECSErr) validator.Validator { return lookslike.MustCompile(map[string]interface{}{ - "error": hbtestllext.IsECSErrExact(eErr), + "error": hbtestllext.IsECSErr(eErr), }) } diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go index eb26a2cbec60..2294ce0fa686 100644 --- a/heartbeat/hbtestllext/isdefs.go +++ b/heartbeat/hbtestllext/isdefs.go @@ -18,6 +18,7 @@ package hbtestllext import ( + "strings" "time" "github.com/elastic/go-lookslike/isdef" @@ -61,7 +62,7 @@ var IsMonitorState = isdef.Is("isState", func(path llpath.Path, v interface{}) * return llresult.ValidResult(path) }) -var IsECSErrExact = func(expectedErr *ecserr.ECSErr) isdef.IsDef { +var IsECSErr = func(expectedErr *ecserr.ECSErr) isdef.IsDef { return isdef.Is("matches ECS ERR", func(path llpath.Path, v interface{}) *llresult.Results { // This conditional is a bit awkward, apparently there's a bug in lookslike where a pointer // value is de-referenced, so a given *ecserr.ECSErr turns into an ecserr.ECSErr @@ -73,7 +74,7 @@ var IsECSErrExact = func(expectedErr *ecserr.ECSErr) isdef.IsDef { givenErr = &givenErrNoPtr if expectedErr.Code != givenErr.Code { - return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", expectedErr.Code, expectedErr.Code) + return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", expectedErr.Code, givenErr.Code) } if expectedErr.Type != givenErr.Type { @@ -87,3 +88,26 @@ var IsECSErrExact = func(expectedErr *ecserr.ECSErr) isdef.IsDef { return llresult.ValidResult(path) }) } + +var IsECSErrMatchingCode = func(ecode ecserr.ECode, messageContains string) isdef.IsDef { + return isdef.Is("matches ECS ERR", func(path llpath.Path, v interface{}) *llresult.Results { + // This conditional is a bit awkward, apparently there's a bug in lookslike where a pointer + // value is de-referenced, so a given *ecserr.ECSErr turns into an ecserr.ECSErr + var givenErr *ecserr.ECSErr + givenErrNoPtr, ok := v.(ecserr.ECSErr) + if !ok { + return llresult.SimpleResult(path, false, "ecserr.ECSErr expected, got %v", v) + } + givenErr = &givenErrNoPtr + + if ecode != givenErr.Code { + return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", ecode, givenErr.Code) + } + + if !strings.Contains(givenErr.Message, messageContains) { + return llresult.SimpleResult(path, false, "ECS error type does not match, expected '%s' to contain '%s'", givenErr.Message, messageContains) + } + + return llresult.ValidResult(path) + }) +} diff --git a/heartbeat/monitors/active/dialchain/dialers.go b/heartbeat/monitors/active/dialchain/dialers.go index c856a0712ed2..4163adb34d51 100644 --- a/heartbeat/monitors/active/dialchain/dialers.go +++ b/heartbeat/monitors/active/dialchain/dialers.go @@ -23,12 +23,13 @@ import ( "strconv" "time" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/elastic-agent-libs/transport" + + "github.com/elastic/beats/v7/heartbeat/ecserr" "github.com/elastic/beats/v7/heartbeat/eventext" "github.com/elastic/beats/v7/heartbeat/look" "github.com/elastic/beats/v7/libbeat/beat" - "github.com/elastic/elastic-agent-libs/logp" - "github.com/elastic/elastic-agent-libs/mapstr" - "github.com/elastic/elastic-agent-libs/transport" ) // TCPDialer creates a new NetDialer with constant event fields and default @@ -92,8 +93,7 @@ func CreateNetDialer(timeout time.Duration) NetDialer { addresses, err := net.LookupHost(host) if err != nil { - logp.Warn(`DNS lookup failure "%s": %v`, host, err) - return nil, err + return nil, ecserr.NewDNSLookupFailedErr(host, err) } // dial via host IP by randomized iteration of known IPs @@ -102,7 +102,7 @@ func CreateNetDialer(timeout time.Duration) NetDialer { start := time.Now() conn, err := transport.DialWith(dialer, network, host, addresses, port) if err != nil { - return nil, err + return nil, ecserr.NewCouldNotConnectErr(host, port, err) } end := time.Now() diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index e3d841b69386..48df6054776b 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -617,7 +617,6 @@ func TestConnRefusedJob(t *testing.T) { require.NoError(t, err) url := fmt.Sprintf("http://%s:%d", ip, port) - event := sendSimpleTLSRequest(t, url, false) testslike.Test( @@ -625,7 +624,7 @@ func TestConnRefusedJob(t *testing.T) { lookslike.Strict(lookslike.Compose( hbtest.BaseChecks(ip, "down", "http"), hbtest.SummaryChecks(0, 1), - hbtest.ErrorChecks(url, "io"), + hbtest.ECSErrCodeChecks(ecserr.CODE_NET_COULD_NOT_CONNECT, fmt.Sprintf("%s:%d", ip, port)), urlChecks(url), )), event.Fields, @@ -647,7 +646,7 @@ func TestUnreachableJob(t *testing.T) { lookslike.Strict(lookslike.Compose( hbtest.BaseChecks(ip, "down", "http"), hbtest.SummaryChecks(0, 1), - hbtest.ErrorChecks(url, "io"), + hbtest.ECSErrCodeChecks(ecserr.CODE_NET_COULD_NOT_CONNECT, url), urlChecks(url), )), event.Fields, diff --git a/heartbeat/monitors/active/tcp/tcp_test.go b/heartbeat/monitors/active/tcp/tcp_test.go index 10151a56b7aa..62b01f4a4ead 100644 --- a/heartbeat/monitors/active/tcp/tcp_test.go +++ b/heartbeat/monitors/active/tcp/tcp_test.go @@ -28,14 +28,16 @@ import ( "github.com/stretchr/testify/require" - "github.com/elastic/beats/v7/heartbeat/hbtest" - "github.com/elastic/beats/v7/heartbeat/hbtestllext" - "github.com/elastic/beats/v7/libbeat/beat" - btesting "github.com/elastic/beats/v7/libbeat/testing" "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/go-lookslike" "github.com/elastic/go-lookslike/testslike" "github.com/elastic/go-lookslike/validator" + + "github.com/elastic/beats/v7/heartbeat/ecserr" + "github.com/elastic/beats/v7/heartbeat/hbtest" + "github.com/elastic/beats/v7/heartbeat/hbtestllext" + "github.com/elastic/beats/v7/libbeat/beat" + btesting "github.com/elastic/beats/v7/libbeat/testing" ) func testTCPCheck(t *testing.T, host string, port uint16) *beat.Event { @@ -130,7 +132,7 @@ func TestConnectionRefusedEndpointJob(t *testing.T) { hbtest.BaseChecks(ip, "down", "tcp"), hbtest.SummaryChecks(0, 1), hbtest.SimpleURLChecks(t, "tcp", ip, port), - hbtest.ErrorChecks(dialErr, "io"), + hbtest.ECSErrCodeChecks(ecserr.CODE_NET_COULD_NOT_CONNECT, dialErr), )), event.Fields, ) @@ -148,7 +150,7 @@ func TestUnreachableEndpointJob(t *testing.T) { hbtest.BaseChecks(ip, "down", "tcp"), hbtest.SummaryChecks(0, 1), hbtest.SimpleURLChecks(t, "tcp", ip, port), - hbtest.ErrorChecks(dialErr, "io"), + hbtest.ECSErrCodeChecks(ecserr.CODE_NET_COULD_NOT_CONNECT, dialErr), )), event.Fields, ) From 56a0cd23755cbcf54ae7c9bad5d59f6dc8f2f0af Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 15 Aug 2022 16:22:00 -0500 Subject: [PATCH 064/102] Fixup connection errors in HTTP tests --- heartbeat/hbtestllext/isdefs.go | 2 +- heartbeat/monitors/active/http/http_test.go | 2 +- heartbeat/monitors/active/http/task.go | 16 +++++++++++----- .../wrappers/monitorstate/monitorstate.go | 2 +- 4 files changed, 14 insertions(+), 8 deletions(-) diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go index 2294ce0fa686..7e5de4f11b1f 100644 --- a/heartbeat/hbtestllext/isdefs.go +++ b/heartbeat/hbtestllext/isdefs.go @@ -78,7 +78,7 @@ var IsECSErr = func(expectedErr *ecserr.ECSErr) isdef.IsDef { } if expectedErr.Type != givenErr.Type { - return llresult.SimpleResult(path, false, "ECS error code does not match, expected %s, got %s", expectedErr.Type, givenErr.Type) + return llresult.SimpleResult(path, false, "ECS error message does not match, expected %s, got %s", expectedErr.Type, givenErr.Type) } if expectedErr.Message != givenErr.Message { diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 48df6054776b..5cce1f974a0b 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -646,7 +646,7 @@ func TestUnreachableJob(t *testing.T) { lookslike.Strict(lookslike.Compose( hbtest.BaseChecks(ip, "down", "http"), hbtest.SummaryChecks(0, 1), - hbtest.ECSErrCodeChecks(ecserr.CODE_NET_COULD_NOT_CONNECT, url), + hbtest.ECSErrCodeChecks(ecserr.CODE_NET_COULD_NOT_CONNECT, fmt.Sprintf("%s:%d", ip, port)), urlChecks(url), )), event.Fields, diff --git a/heartbeat/monitors/active/http/task.go b/heartbeat/monitors/active/http/task.go index 6acd855fb678..530747b166bc 100644 --- a/heartbeat/monitors/active/http/task.go +++ b/heartbeat/monitors/active/http/task.go @@ -32,9 +32,14 @@ import ( "sync" "time" - "github.com/elastic/beats/v7/heartbeat/monitors/active/dialchain/tlsmeta" "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/ecserr" + "github.com/elastic/beats/v7/heartbeat/monitors/active/dialchain/tlsmeta" + + "github.com/elastic/elastic-agent-libs/transport/httpcommon" + "github.com/elastic/elastic-agent-libs/transport/tlscommon" + "github.com/elastic/beats/v7/heartbeat/eventext" "github.com/elastic/beats/v7/heartbeat/look" "github.com/elastic/beats/v7/heartbeat/monitors" @@ -42,8 +47,6 @@ import ( "github.com/elastic/beats/v7/heartbeat/monitors/jobs" "github.com/elastic/beats/v7/heartbeat/reason" "github.com/elastic/beats/v7/libbeat/beat" - "github.com/elastic/elastic-agent-libs/transport/httpcommon" - "github.com/elastic/elastic-agent-libs/transport/tlscommon" ) type requestFactory func() (*http.Request, error) @@ -227,7 +230,7 @@ func execPing( timeout time.Duration, validator multiValidator, responseConfig responseConfig, -) (end time.Time, err reason.Reason) { +) (end time.Time, err error) { ctx, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() @@ -240,8 +243,11 @@ func execPing( // since that logic is for adding metadata relating to completed HTTP transactions that have errored // in other ways if resp == nil || errReason != nil { + var ecsErr *ecserr.ECSErr var urlError *url.Error - if errors.As(errReason.Unwrap(), &urlError) { + if errors.As(errReason.Unwrap(), &ecsErr) { + return time.Now(), ecsErr + } else if errors.As(errReason.Unwrap(), &urlError) { var certErr x509.CertificateInvalidError if errors.As(urlError, &certErr) { tlsmeta.AddCertMetadata(event.Fields, []*x509.Certificate{certErr.Cert}) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index f2e42b76a6ed..7c20a07d6c44 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -26,7 +26,7 @@ import ( // must occur for us to end a flapping state. FlappingThreshold-1 is the number // of consecutive checks that is insufficient to start a new state, but rather to // keep the current state and turn it into a flapping state. -const FlappingThreshold = 7 +const FlappingThreshold = 3 type StateStatus string From 2af1a0a1f231d09da7d7390f56d7e641157d4897 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 15 Aug 2022 16:42:59 -0500 Subject: [PATCH 065/102] Fix broken HTTP errors --- heartbeat/monitors/active/http/task.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/heartbeat/monitors/active/http/task.go b/heartbeat/monitors/active/http/task.go index 530747b166bc..cb07b7aa87f0 100644 --- a/heartbeat/monitors/active/http/task.go +++ b/heartbeat/monitors/active/http/task.go @@ -27,6 +27,7 @@ import ( "net" "net/http" "net/url" + "os" "strconv" "strings" "sync" @@ -320,6 +321,14 @@ func execRequest(client *http.Client, req *http.Request) (start time.Time, resp start = time.Now() resp, err := client.Do(req) + // Since the HTTP client is very old we can't use errors.Is, but must + // use this ancient bit of cruft to determine if we couldn't connect + // The nomenclature about this being a timeout is actually wrong + // this happens on all sorts of connection errors, so it's double lame + if os.IsTimeout(err) { + err = ecserr.NewCouldNotConnectErr(req.URL.Hostname(), req.URL.Port(), err) + } + if err != nil { return start, nil, reason.IOFailed(err) } From 8e67dd97a751a504be05ca8d7d16590aaf1f9b32 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 16 Aug 2022 16:24:52 -0500 Subject: [PATCH 066/102] Make linter happy --- heartbeat/hbtest/hbtestutil.go | 12 +----------- heartbeat/monitors/active/http/http_test.go | 1 - .../monitors/wrappers/monitorstate/monitorstate.go | 2 +- 3 files changed, 2 insertions(+), 13 deletions(-) diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index 7760f2739b37..0b483b3e1d03 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -64,8 +64,6 @@ func HelloWorldHandler(status int) http.HandlerFunc { w.Header().Set("Location", "/somewhere") } w.WriteHeader(status) - //nolint:errcheck // There are no new changes to this line but - // linter has been activated in the meantime. We'll cleanup separately. _, _ = io.WriteString(w, HelloWorldBody) }, ) @@ -83,8 +81,6 @@ func SizedResponseHandler(bytes int) http.HandlerFunc { return http.HandlerFunc( func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) - //nolint:errcheck // There are no new changes to this line but - // linter has been activated in the meantime. We'll cleanup separately. _, _ = io.WriteString(w, body.String()) }, ) @@ -97,8 +93,6 @@ func CustomResponseHandler(body []byte, status int, extraHeaders map[string]stri w.Header().Add(key, val) } w.WriteHeader(status) - //nolint:errcheck // There are no new changes to this line but - // linter has been activated in the meantime. We'll cleanup separately. _, _ = w.Write(body) }, ) @@ -287,8 +281,6 @@ func CertToTempFile(t *testing.T, cert *x509.Certificate) *os.File { // disk, not memory, so this little bit of extra work is worthwhile certFile, err := ioutil.TempFile("", "sslcert") require.NoError(t, err) - //nolint:errcheck // There are no new changes to this line but - // linter has been activated in the meantime. We'll cleanup separately. _, _ = certFile.WriteString(x509util.CertToPEMString(cert)) return certFile } @@ -307,9 +299,7 @@ func StartHTTPSServer(t *testing.T, tlsCert tls.Certificate) (host string, port srv := &http.Server{Handler: HelloWorldHandler(200)} go func() { - //nolint:errcheck // There are no new changes to this line but - // linter has been activated in the meantime. We'll cleanup separately. - srv.Serve(l) + _ = srv.Serve(l) }() host, port, err = net.SplitHostPort(l.Addr().String()) diff --git a/heartbeat/monitors/active/http/http_test.go b/heartbeat/monitors/active/http/http_test.go index 5cce1f974a0b..efc3fe15c572 100644 --- a/heartbeat/monitors/active/http/http_test.go +++ b/heartbeat/monitors/active/http/http_test.go @@ -594,7 +594,6 @@ func TestHTTPSx509Auth(t *testing.T) { ClientCAs: clientCerts, MinVersion: tls.VersionTLS12, } - tlsConf.BuildNameToCertificate() server := httptest.NewUnstartedServer(hbtest.HelloWorldHandler(http.StatusOK)) server.TLS = tlsConf diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 7c20a07d6c44..79f20e4d888b 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -71,7 +71,7 @@ type State struct { } func (s *State) incrementCounters(status StateStatus) { - s.DurationMs = time.Now().Sub(s.StartedAt).Milliseconds() + s.DurationMs = time.Since(s.StartedAt).Milliseconds() s.Checks++ if status == StatusUp { s.Up++ From 107a52b0a6c20ebe19cd45c82d41ff090575c516 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 16 Aug 2022 19:14:42 -0500 Subject: [PATCH 067/102] Make linter happy, remove runner XML --- heartbeat/hbtest/hbtestutil.go | 1 + ...heartbeat x-pack docker compose up.run.xml | 23 ------------------- .../integ test x-pack_heartbeat.run.xml | 13 ----------- 3 files changed, 1 insertion(+), 36 deletions(-) delete mode 100644 x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml delete mode 100644 x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index 0b483b3e1d03..68163ac29e38 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -297,6 +297,7 @@ func StartHTTPSServer(t *testing.T, tlsCert tls.Certificate) (host string, port }) require.NoError(t, err) + //nolint:gosec // we don't care about a slowloris attack on a test srv srv := &http.Server{Handler: HelloWorldHandler(200)} go func() { _ = srv.Serve(l) diff --git a/x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml b/x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml deleted file mode 100644 index c87758cc4fa2..000000000000 --- a/x-pack/heartbeat.run/heartbeat x-pack docker compose up.run.xml +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - \ No newline at end of file diff --git a/x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml b/x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml deleted file mode 100644 index 23806757d409..000000000000 --- a/x-pack/heartbeat.run/integ test x-pack_heartbeat.run.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - \ No newline at end of file From bff7ac8d75b39bd1f662baf1a0ce6e0e14a41ba1 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 16 Aug 2022 19:49:12 -0500 Subject: [PATCH 068/102] Make linter happy --- heartbeat/hbtest/hbtestutil.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/heartbeat/hbtest/hbtestutil.go b/heartbeat/hbtest/hbtestutil.go index 68163ac29e38..cdf21436f74d 100644 --- a/heartbeat/hbtest/hbtestutil.go +++ b/heartbeat/hbtest/hbtestutil.go @@ -297,8 +297,8 @@ func StartHTTPSServer(t *testing.T, tlsCert tls.Certificate) (host string, port }) require.NoError(t, err) - //nolint:gosec // we don't care about a slowloris attack on a test srv - srv := &http.Server{Handler: HelloWorldHandler(200)} + // We set ReadHeaderTimeout to make the gosec lint happy + srv := &http.Server{Handler: HelloWorldHandler(200), ReadHeaderTimeout: time.Second} go func() { _ = srv.Serve(l) }() From 55cbff034b1b0062cf120b93a317c0dd7d6df2a9 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 09:20:28 -0500 Subject: [PATCH 069/102] Make linter happy --- heartbeat/monitors/active/tcp/helpers_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/heartbeat/monitors/active/tcp/helpers_test.go b/heartbeat/monitors/active/tcp/helpers_test.go index 781c5ad28e97..aee494a91d71 100644 --- a/heartbeat/monitors/active/tcp/helpers_test.go +++ b/heartbeat/monitors/active/tcp/helpers_test.go @@ -23,6 +23,7 @@ import ( "net/http" "net/http/httptest" "testing" + "time" "github.com/stretchr/testify/require" @@ -80,7 +81,7 @@ func newHostTestServer(handler http.Handler, host string) (*httptest.Server, err server := &httptest.Server{ Listener: listener, - Config: &http.Server{Handler: handler}, + Config: &http.Server{Handler: handler, ReadHeaderTimeout: time.Second}, } server.Start() From 363a6f83d6512c15023650807e7e487b4037a9c8 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 09:52:14 -0500 Subject: [PATCH 070/102] Fix integration test targeting --- .../{esloader_integration_test.go => esloader_test.go} | 2 ++ 1 file changed, 2 insertions(+) rename heartbeat/monitors/wrappers/monitorstate/{esloader_integration_test.go => esloader_test.go} (99%) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_test.go similarity index 99% rename from heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go rename to heartbeat/monitors/wrappers/monitorstate/esloader_test.go index ffa850bba224..59fd375e1c56 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_integration_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_test.go @@ -15,6 +15,8 @@ // specific language governing permissions and limitations // under the License. +//go:build integration + package monitorstate import ( From 8500f22863e5a453cb8f4d04f9694d8241614194 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 13:05:51 -0500 Subject: [PATCH 071/102] Make linter happy --- heartbeat/monitors/wrappers/monitorstate/tracker_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index a39c8e7657fb..5ea049b11f46 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -28,7 +28,7 @@ func TestTrackerRecord(t *testing.T) { mst := NewTracker(NilStateLoader) ms := mst.RecordStatus(monId, StatusUp) require.Equal(t, StatusUp, ms.Status) - requireMSCounts(t, ms, 1, 0) + requireMSStatusCount(t, ms, StatusUp, 1) for i := 0; i < FlappingThreshold; i++ { ms = mst.RecordStatus(monId, StatusUp) @@ -38,5 +38,5 @@ func TestTrackerRecord(t *testing.T) { ms = mst.RecordStatus(monId, StatusDown) require.Equal(t, StatusDown, ms.Status) - requireMSCounts(t, ms, 0, 1) + requireMSStatusCount(t, ms, StatusDown, 1) } From 131e187c6169cabb51c2fa979a87a4edccc152f4 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 15:35:27 -0500 Subject: [PATCH 072/102] Integration tests fixed in non-xpack heartbeat --- heartbeat/docker-compose.yml | 26 +++----------------------- heartbeat/magefile.go | 12 +++++++++--- 2 files changed, 12 insertions(+), 26 deletions(-) diff --git a/heartbeat/docker-compose.yml b/heartbeat/docker-compose.yml index ace731f7bbbb..bed468effa80 100644 --- a/heartbeat/docker-compose.yml +++ b/heartbeat/docker-compose.yml @@ -1,39 +1,19 @@ version: '2.3' services: - beat: - build: ${PWD}/. - depends_on: - - proxy_dep - environment: - - REDIS_HOST=redis - - REDIS_PORT=6379 - - ES_HOST=elasticsearch - - ES_USER=heartbeat_user - - ES_PASS=testing - - ES_PORT=9200 - working_dir: /go/src/github.com/elastic/beats/heartbeat - volumes: - - ${PWD}/..:/go/src/github.com/elastic/beats/ - # We launch docker containers to test docker autodiscover: - - /var/run/docker.sock:/var/run/docker.sock - command: make - # This is a proxy used to block beats until all services are healthy. # See: https://github.com/docker/compose/issues/4369 proxy_dep: image: busybox depends_on: elasticsearch: { condition: service_healthy } - redis: { condition: service_healthy } elasticsearch: extends: - file: ${ES_BEATS}/testing/environments/${TESTING_ENVIRONMENT}.yml + file: ${ES_BEATS}/testing/environments/${STACK_ENVIRONMENT}.yml service: elasticsearch healthcheck: test: ["CMD-SHELL", "curl -u admin:testing -s http://localhost:9200/_cat/health?h=status | grep -q green"] retries: 300 interval: 1s - - redis: - build: ${PWD}/tests/docker_support/redis + ports: + - 9200:9200 diff --git a/heartbeat/magefile.go b/heartbeat/magefile.go index f560ad3d9b1a..10e67a289e28 100644 --- a/heartbeat/magefile.go +++ b/heartbeat/magefile.go @@ -21,6 +21,7 @@ package main import ( + "context" "fmt" "time" @@ -36,8 +37,6 @@ import ( //mage:import "github.com/elastic/beats/v7/dev-tools/mage/target/unittest" //mage:import - "github.com/elastic/beats/v7/dev-tools/mage/target/integtest" - //mage:import _ "github.com/elastic/beats/v7/dev-tools/mage/target/integtest/docker" //mage:import _ "github.com/elastic/beats/v7/dev-tools/mage/target/test" @@ -46,7 +45,6 @@ import ( func init() { common.RegisterCheckDeps(Update) unittest.RegisterPythonTestDeps(Fields) - integtest.RegisterPythonTestDeps(Fields) } // Package packages the Beat for distribution. @@ -88,6 +86,14 @@ func Update() { mg.SerialDeps(Fields, FieldDocs, Config) } +func IntegTest() { + mg.SerialDeps(GoIntegTest) +} + +func GoIntegTest(ctx context.Context) error { + return devtools.GoIntegTestFromHost(ctx, devtools.DefaultGoTestIntegrationFromHostArgs()) +} + func FieldDocs() error { return devtools.Docs.FieldDocs("fields.yml") } From c44670594e553b1fd12557edd52be48b978ae850 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 16:02:15 -0500 Subject: [PATCH 073/102] Add empty pythonIntegTest mage targets to make CI happy --- heartbeat/magefile.go | 4 ++++ x-pack/heartbeat/magefile.go | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/heartbeat/magefile.go b/heartbeat/magefile.go index 10e67a289e28..98a8c9f8b13b 100644 --- a/heartbeat/magefile.go +++ b/heartbeat/magefile.go @@ -94,6 +94,10 @@ func GoIntegTest(ctx context.Context) error { return devtools.GoIntegTestFromHost(ctx, devtools.DefaultGoTestIntegrationFromHostArgs()) } +func PythonIntegTest() { + // intentionally blank, CI runs this for every beat +} + func FieldDocs() error { return devtools.Docs.FieldDocs("fields.yml") } diff --git a/x-pack/heartbeat/magefile.go b/x-pack/heartbeat/magefile.go index 829d8ec7016c..b68086a3327a 100644 --- a/x-pack/heartbeat/magefile.go +++ b/x-pack/heartbeat/magefile.go @@ -83,6 +83,10 @@ func IntegTest() { mg.SerialDeps(GoIntegTest) } +func PythonIntegTest() { + // intentionally blank, CI runs this for every beat +} + func GoIntegTest(ctx context.Context) error { return devtools.GoIntegTestFromHost(ctx, devtools.DefaultGoTestIntegrationFromHostArgs()) } From 43dd0fcc19cc622724bba3f285a866f93786de62 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 16:12:38 -0500 Subject: [PATCH 074/102] Remove flap history field from state.ends --- heartbeat/_meta/fields.common.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 0e01df9f51fe..345e9232ff20 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -158,8 +158,6 @@ - name: down type: integer description: total down checks run - - name: flap_history - enabled: false - key: summary title: "Monitor summary" From a05c1fd952ae48be2b1f883c300fa2a5a2537c33 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 17 Aug 2022 17:49:29 -0500 Subject: [PATCH 075/102] Fix nesting of state.ends --- heartbeat/_meta/fields.common.yml | 60 +++++++++++------------ heartbeat/docs/fields.asciidoc | 77 ++---------------------------- heartbeat/include/fields.go | 2 +- x-pack/heartbeat/include/fields.go | 2 +- 4 files changed, 35 insertions(+), 106 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index 345e9232ff20..03f5236d6113 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -128,36 +128,36 @@ description: total down checks run - name: flap_history enabled: false - - name: ends - type: group - description: the state that was ended by this state - fields: - - name: id - type: integer - description: > - ID of this state - - name: started_at - type: date - description: > - First time state with this ID was seen - - name: duration_ms - type: date - description: > - Length of time this state has existed in millis - - name: status - type: keyword - description: > - The current status, "up", "down", or "flapping" - any state can change into flapping. - - name: checks - type: integer - description: total checks run - - name: up - type: integer - description: total up checks run - - name: down - type: integer - description: total down checks run + - name: ends + type: object + description: the state that was ended by this state + fields: + - name: id + type: integer + description: > + ID of this state + - name: started_at + type: date + description: > + First time state with this ID was seen + - name: duration_ms + type: date + description: > + Length of time this state has existed in millis + - name: status + type: keyword + description: > + The current status, "up", "down", or "flapping" + any state can change into flapping. + - name: checks + type: integer + description: total checks run + - name: up + type: integer + description: total up checks run + - name: down + type: integer + description: total down checks run - key: summary title: "Monitor summary" diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index beb7dd550470..f2bc433edfb7 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -16386,83 +16386,12 @@ Object is not enabled. -- -[float] -=== ends - -the state that was ended by this state - - -*`ends.id`*:: -+ --- -ID of this state - - -type: integer - --- - -*`ends.started_at`*:: -+ --- -First time state with this ID was seen - - -type: date - --- - -*`ends.duration_ms`*:: +*`state.ends`*:: + -- -Length of time this state has existed in millis - - -type: date - --- - -*`ends.status`*:: -+ --- -The current status, "up", "down", or "flapping" any state can change into flapping. - - -type: keyword - --- - -*`ends.checks`*:: -+ --- -total checks run - -type: integer - --- - -*`ends.up`*:: -+ --- -total up checks run - -type: integer - --- - -*`ends.down`*:: -+ --- -total down checks run - -type: integer - --- +the state that was ended by this state -*`ends.flap_history`*:: -+ --- -Object is not enabled. +type: object -- diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 22c17c22dcb2..23d633f8e560 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 zlib format compressed 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 a2f1cc5231ee..b150d76d853e 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 zlib format compressed contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } From 54c770598a295d597f7913b1a3e0199a6a5c67a2 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 29 Aug 2022 13:02:52 -0500 Subject: [PATCH 076/102] Add geo config --- heartbeat/beater/heartbeat.go | 9 ++++++++- heartbeat/config/config.go | 7 +++++++ heartbeat/monitors/factory.go | 24 ++++++++++++++++++------ heartbeat/monitors/mocks.go | 13 +++++++++---- x-pack/heartbeat/scenarios/framework.go | 14 ++++++++++---- 5 files changed, 52 insertions(+), 15 deletions(-) diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 9af62462975f..8e260be3445d 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -109,7 +109,14 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { scheduler: sched, // monitorFactory is the factory used for creating all monitor instances, // wiring them up to everything needed to actually execute. - monitorFactory: monitors.NewFactory(b.Info, sched.Add, stateLoader, plugin.GlobalPluginsReg, pipelineClientFactory), + monitorFactory: monitors.NewFactory(monitors.FactoryParams{ + BeatInfo: b.Info, + AddTask: sched.Add, + StateLoader: stateLoader, + PluginsReg: plugin.GlobalPluginsReg, + PipelineClientFactory: pipelineClientFactory, + Location: parsedConfig.Location, + }), } return bt, nil } diff --git a/heartbeat/config/config.go b/heartbeat/config/config.go index 324f069d83a9..9cb7468fd0fa 100644 --- a/heartbeat/config/config.go +++ b/heartbeat/config/config.go @@ -22,9 +22,15 @@ package config import ( "github.com/elastic/beats/v7/libbeat/autodiscover" + "github.com/elastic/beats/v7/libbeat/processors/util" conf "github.com/elastic/elastic-agent-libs/config" ) +type LocationWithID struct { + ID string `config:"id"` + Geo util.GeoConfig `config:"geo"` +} + // Config defines the structure of heartbeat.yml. type Config struct { RunOnce bool `config:"run_once"` @@ -33,6 +39,7 @@ type Config struct { Scheduler Scheduler `config:"scheduler"` Autodiscover *autodiscover.Config `config:"autodiscover"` Jobs map[string]*JobLimit `config:"jobs"` + Location LocationWithID `config:"location` } type JobLimit struct { diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index 9c9e1af5bb5b..7a9fc41e9ecc 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -25,6 +25,7 @@ import ( "github.com/elastic/elastic-agent-libs/logp" "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/monitors/plugin" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" @@ -51,6 +52,7 @@ type RunnerFactory struct { pluginsReg *plugin.PluginsReg logger *logp.Logger pipelineClientFactory PipelineClientFactory + location config.LocationWithID } type PipelineClientFactory func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) @@ -74,16 +76,26 @@ type publishSettings struct { DataSet string `config:"dataset"` } +type FactoryParams struct { + BeatInfo beat.Info + AddTask scheduler.AddTask + StateLoader monitorstate.StateLoader + PluginsReg *plugin.PluginsReg + PipelineClientFactory PipelineClientFactory + Location config.LocationWithID +} + // NewFactory takes a scheduler and creates a RunnerFactory that can create cfgfile.Runner(Monitor) objects. -func NewFactory(info beat.Info, addTask scheduler.AddTask, stateLoader monitorstate.StateLoader, pluginsReg *plugin.PluginsReg, pcf PipelineClientFactory) *RunnerFactory { +func NewFactory(fp FactoryParams) *RunnerFactory { return &RunnerFactory{ - info: info, - addTask: addTask, + info: fp.BeatInfo, + addTask: fp.AddTask, byId: map[string]*Monitor{}, mtx: &sync.Mutex{}, - pluginsReg: pluginsReg, + pluginsReg: fp.PluginsReg, logger: logp.L(), - pipelineClientFactory: pcf, + pipelineClientFactory: fp.PipelineClientFactory, + location: fp.Location, } } @@ -220,7 +232,7 @@ func newCommonPublishConfigs(info beat.Info, cfg *conf.C) (pipetool.ConfigEditor }, nil } -// preProcessors sets up the required event.dataset, data_stream.*, and write index processors for future event publishes. +// preProcessors sets up the required geo, event.dataset, data_stream.*, and write index processors for future event publishes. func preProcessors(info beat.Info, settings publishSettings, monitorType string) (procs *processors.Processors, err error) { procs = processors.NewList(nil) diff --git a/heartbeat/monitors/mocks.go b/heartbeat/monitors/mocks.go index 1d513cfada5f..17b077822eed 100644 --- a/heartbeat/monitors/mocks.go +++ b/heartbeat/monitors/mocks.go @@ -75,10 +75,15 @@ func makeMockFactory(pluginsReg *plugin.PluginsReg) (factory *RunnerFactory, sch nil, true, ) - - return NewFactory(info, sched.Add, monitorstate.NilStateLoader, pluginsReg, func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { - c, _ := pipeline.Connect() - return SyncPipelineClientAdaptor{C: c}, nil + return NewFactory(FactoryParams{ + BeatInfo: info, + AddTask: sched.Add, + StateLoader: monitorstate.NilStateLoader, + PluginsReg: pluginsReg, + PipelineClientFactory: func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { + c, _ := pipeline.Connect() + return SyncPipelineClientAdaptor{C: c}, nil + }, }), sched, sched.Stop diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 0b0057a09a7a..6acf247169bb 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -10,6 +10,7 @@ import ( "testing" "time" + "github.com/elastic/beats/v7/heartbeat/monitors/plugin" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" @@ -21,7 +22,6 @@ import ( "github.com/elastic/elastic-agent-libs/monitoring" "github.com/elastic/beats/v7/heartbeat/monitors" - "github.com/elastic/beats/v7/heartbeat/monitors/plugin" "github.com/elastic/beats/v7/heartbeat/scheduler" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/publisher/pipeline" @@ -172,9 +172,15 @@ func setupFactoryAndSched() (factory *monitors.RunnerFactory, sched *scheduler.S true, ) - return monitors.NewFactory(info, sched.Add, monitorstate.NilStateLoader, plugin.GlobalPluginsReg, func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { - c, _ := pipeline.Connect() - return monitors.SyncPipelineClientAdaptor{C: c}, nil + return monitors.NewFactory(monitors.FactoryParams{ + BeatInfo: info, + AddTask: sched.Add, + StateLoader: monitorstate.NilStateLoader, + PluginsReg: plugin.GlobalPluginsReg, + PipelineClientFactory: func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { + c, _ := pipeline.Connect() + return monitors.SyncPipelineClientAdaptor{C: c}, nil + }, }), sched, sched.Stop From c8f8a829d888960ecfbbba407cda63d8197844dd Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 29 Aug 2022 17:00:24 -0500 Subject: [PATCH 077/102] Initial tests and functionality for geo per monitor --- heartbeat/beater/heartbeat.go | 2 +- heartbeat/config/config.go | 2 +- heartbeat/monitors/factory.go | 46 +++++++++++++--- heartbeat/monitors/factory_test.go | 65 +++++++++++++++++++---- heartbeat/monitors/stdfields/stdfields.go | 2 + 5 files changed, 99 insertions(+), 18 deletions(-) diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 8e260be3445d..5a9d9c5bf9aa 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -115,7 +115,7 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { StateLoader: stateLoader, PluginsReg: plugin.GlobalPluginsReg, PipelineClientFactory: pipelineClientFactory, - Location: parsedConfig.Location, + BeatLocation: parsedConfig.Location, }), } return bt, nil diff --git a/heartbeat/config/config.go b/heartbeat/config/config.go index 9cb7468fd0fa..e3950cd66152 100644 --- a/heartbeat/config/config.go +++ b/heartbeat/config/config.go @@ -39,7 +39,7 @@ type Config struct { Scheduler Scheduler `config:"scheduler"` Autodiscover *autodiscover.Config `config:"autodiscover"` Jobs map[string]*JobLimit `config:"jobs"` - Location LocationWithID `config:"location` + Location *LocationWithID `config:"location` } type JobLimit struct { diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index 7a9fc41e9ecc..903d399be1e5 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -37,6 +37,7 @@ import ( "github.com/elastic/beats/v7/libbeat/processors/actions" "github.com/elastic/beats/v7/libbeat/processors/add_data_stream" "github.com/elastic/beats/v7/libbeat/processors/add_formatted_index" + "github.com/elastic/beats/v7/libbeat/processors/util" "github.com/elastic/beats/v7/libbeat/publisher/pipeline" "github.com/elastic/beats/v7/libbeat/publisher/pipetool" ) @@ -52,7 +53,7 @@ type RunnerFactory struct { pluginsReg *plugin.PluginsReg logger *logp.Logger pipelineClientFactory PipelineClientFactory - location config.LocationWithID + beatLocation *config.LocationWithID } type PipelineClientFactory func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) @@ -82,7 +83,7 @@ type FactoryParams struct { StateLoader monitorstate.StateLoader PluginsReg *plugin.PluginsReg PipelineClientFactory PipelineClientFactory - Location config.LocationWithID + BeatLocation *config.LocationWithID } // NewFactory takes a scheduler and creates a RunnerFactory that can create cfgfile.Runner(Monitor) objects. @@ -95,7 +96,7 @@ func NewFactory(fp FactoryParams) *RunnerFactory { pluginsReg: fp.PluginsReg, logger: logp.L(), pipelineClientFactory: fp.PipelineClientFactory, - location: fp.Location, + beatLocation: fp.BeatLocation, } } @@ -122,7 +123,7 @@ func (f *RunnerFactory) Create(p beat.Pipeline, c *conf.C) (cfgfile.Runner, erro return nil, err } - configEditor, err := newCommonPublishConfigs(f.info, c) + configEditor, err := newCommonPublishConfigs(f.info, f.beatLocation, c) if err != nil { return nil, err } @@ -181,7 +182,7 @@ func (f *RunnerFactory) CheckConfig(config *conf.C) error { return checkMonitorConfig(config, plugin.GlobalPluginsReg) } -func newCommonPublishConfigs(info beat.Info, cfg *conf.C) (pipetool.ConfigEditor, error) { +func newCommonPublishConfigs(info beat.Info, beatLocation *config.LocationWithID, cfg *conf.C) (pipetool.ConfigEditor, error) { var settings publishSettings if err := cfg.Unpack(&settings); err != nil { return nil, err @@ -193,7 +194,15 @@ func newCommonPublishConfigs(info beat.Info, cfg *conf.C) (pipetool.ConfigEditor } // Early stage processors for setting data_stream, event.dataset, and index to write to - preProcs, err := preProcessors(info, settings, sf.Type) + + // Use the monitor-specific location if possible, otherwise use the beat's location + var loc *config.LocationWithID + if sf.Location != nil { + loc = sf.Location + } else { + loc = beatLocation + } + preProcs, err := preProcessors(info, loc, settings, sf.Type) if err != nil { return nil, err } @@ -232,8 +241,10 @@ func newCommonPublishConfigs(info beat.Info, cfg *conf.C) (pipetool.ConfigEditor }, nil } +var geoErrOnce = &sync.Once{} + // preProcessors sets up the required geo, event.dataset, data_stream.*, and write index processors for future event publishes. -func preProcessors(info beat.Info, settings publishSettings, monitorType string) (procs *processors.Processors, err error) { +func preProcessors(info beat.Info, location *config.LocationWithID, settings publishSettings, monitorType string) (procs *processors.Processors, err error) { procs = processors.NewList(nil) var dataset string @@ -246,6 +257,27 @@ func preProcessors(info beat.Info, settings publishSettings, monitorType string) // Always set event.dataset procs.AddProcessor(actions.NewAddFields(mapstr.M{"event": mapstr.M{"dataset": dataset}}, true, true)) + // If we have a location to add, use the add_observer_metadata processor + if location != nil { + var geoM mapstr.M + + geoM, err := util.GeoConfigToMap(location.Geo) + if err != nil { + geoErrOnce.Do(func() { + logp.L().Warnf("could not add heartbeat geo info: %s", err) + }) + } + + obsFields := mapstr.M{ + "observer": mapstr.M{ + "name": location.ID, + "geo": geoM, + }, + } + + procs.AddProcessor(actions.NewAddFields(obsFields, true, true)) + } + // always use synthetics data streams for browser monitors, there is no good reason not to // the default `heartbeat` data stream won't split out network and screenshot data. // at some point we should make all monitors use the `synthetics` datastreams and retire diff --git a/heartbeat/monitors/factory_test.go b/heartbeat/monitors/factory_test.go index 8772b2b71792..1a4990bb64bc 100644 --- a/heartbeat/monitors/factory_test.go +++ b/heartbeat/monitors/factory_test.go @@ -23,13 +23,16 @@ import ( "github.com/elastic/elastic-agent-libs/config" "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/go-lookslike" "github.com/stretchr/testify/require" + hbconfig "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/beat/events" "github.com/elastic/beats/v7/libbeat/common/fmtstr" "github.com/elastic/beats/v7/libbeat/processors/add_data_stream" + "github.com/elastic/beats/v7/libbeat/processors/util" ) var binfo = beat.Info{ @@ -41,14 +44,16 @@ var binfo = beat.Info{ func TestPreProcessors(t *testing.T) { tests := map[string]struct { settings publishSettings + location *hbconfig.LocationWithID expectedIndex string expectedDatastream *add_data_stream.DataStream monitorType string - wantProc bool + wantIndexChange bool wantErr bool }{ "no settings should yield no processor for lightweight monitor": { publishSettings{}, + nil, "", nil, "http", @@ -57,6 +62,7 @@ func TestPreProcessors(t *testing.T) { }, "no settings should yield a data stream processor for browsers": { publishSettings{}, + nil, "synthetics-browser-default", &add_data_stream.DataStream{ Namespace: "default", @@ -69,6 +75,7 @@ func TestPreProcessors(t *testing.T) { }, "exact index should be used exactly": { publishSettings{Index: *fmtstr.MustCompileEvent("test")}, + nil, "test", nil, "http", @@ -83,6 +90,7 @@ func TestPreProcessors(t *testing.T) { Type: "myType", }, }, + nil, "myType-myDataset-myNamespace", &add_data_stream.DataStream{ Namespace: "myNamespace", @@ -97,6 +105,7 @@ func TestPreProcessors(t *testing.T) { publishSettings{ DataStream: &add_data_stream.DataStream{}, }, + nil, "synthetics-browser-default", &add_data_stream.DataStream{ Namespace: "default", @@ -107,33 +116,71 @@ func TestPreProcessors(t *testing.T) { true, false, }, + "with location": { + publishSettings{}, + &hbconfig.LocationWithID{ + ID: "TestID", + Geo: util.GeoConfig{ + Name: "geo name", + Location: "38.889722, -77.008889", + }, + }, + "", + nil, + "http", + false, + false, + }, } for name, tt := range tests { t.Run(name, func(t *testing.T) { e := beat.Event{Meta: mapstr.M{}, Fields: mapstr.M{}} - procs, err := preProcessors(binfo, tt.settings, tt.monitorType) + procs, err := preProcessors(binfo, tt.location, tt.settings, tt.monitorType) if tt.wantErr == true { require.Error(t, err) return } require.NoError(t, err) - // If we're just setting event.dataset we only get the 1 - // otherwise we get a second add_data_stream processor - if !tt.wantProc { - require.Len(t, procs.List, 1) - return + expectedProcs := 1 + if tt.location != nil { + expectedProcs++ } - require.Len(t, procs.List, 2) + if tt.wantIndexChange { + expectedProcs++ + } + + require.Len(t, procs.List, expectedProcs) _, err = procs.Run(&e) t.Run("index name should be set", func(t *testing.T) { require.NoError(t, err) - require.Equal(t, tt.expectedIndex, e.Meta[events.FieldMetaRawIndex]) + if tt.expectedIndex == "" { + require.Nil(t, e.Meta[events.FieldMetaRawIndex]) + } else { + require.Equal(t, tt.expectedIndex, e.Meta[events.FieldMetaRawIndex]) + } }) + if tt.location == nil { + t.Run("observer location data should not be set", func(t *testing.T) { + ok, _ := e.Fields.HasKey("observer") + require.False(t, ok) + }) + } else { + t.Run("observer location data should be set", func(t *testing.T) { + geoM, _ := util.GeoConfigToMap(tt.location.Geo) + lookslike.MustCompile(map[string]interface{}{ + "observer": map[string]interface{}{ + "name": tt.location.ID, + "geo": geoM, + }, + }) + }) + } + eventDs, err := e.GetValue("event.dataset") require.NoError(t, err) diff --git a/heartbeat/monitors/stdfields/stdfields.go b/heartbeat/monitors/stdfields/stdfields.go index 11a6c0cddb78..7a8d0a5cf4bb 100644 --- a/heartbeat/monitors/stdfields/stdfields.go +++ b/heartbeat/monitors/stdfields/stdfields.go @@ -21,6 +21,7 @@ import ( "fmt" "time" + hbconfig "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/scheduler/schedule" "github.com/elastic/elastic-agent-libs/config" ) @@ -49,6 +50,7 @@ type StdMonitorFields struct { ZipUrl *config.C `config:"zip_url"` Local *config.C `config:"local"` } `config:"source"` + Location *hbconfig.LocationWithID `location` } func ConfigToStdMonitorFields(conf *config.C) (StdMonitorFields, error) { From 0211a38c5c22de043abbd5730f649ed4543bfaf6 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 29 Aug 2022 17:44:18 -0500 Subject: [PATCH 078/102] ES loader now supports locations --- heartbeat/beater/heartbeat.go | 20 ++++---- .../wrappers/monitorstate/esloader.go | 49 ++++++++++++------- .../wrappers/monitorstate/helpers_test.go | 5 ++ .../wrappers/monitorstate/monitorstate.go | 18 ++++--- .../monitorstate/monitorstate_test.go | 34 ++++++------- .../monitors/wrappers/monitorstate/tracker.go | 25 +++++----- .../wrappers/monitorstate/tracker_test.go | 7 ++- heartbeat/monitors/wrappers/wrappers.go | 2 +- x-pack/heartbeat/scenarios/framework.go | 19 ++++--- 9 files changed, 101 insertions(+), 78 deletions(-) create mode 100644 heartbeat/monitors/wrappers/monitorstate/helpers_test.go diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 5a9d9c5bf9aa..9433c9d9ccae 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -62,27 +62,29 @@ type EsConfig struct { // New creates a new heartbeat. func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { + parsedConfig := config.DefaultConfig + if err := rawConfig.Unpack(&parsedConfig); err != nil { + return nil, fmt.Errorf("error reading config file: %w", err) + } + + // Connect to ES and setup the State loader esc, err := getESClient(b.Config.Output.Config()) if err != nil { return nil, err } var stateLoader monitorstate.StateLoader if esc != nil { - stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*") + stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*", parsedConfig.Location) } else { stateLoader = monitorstate.NilStateLoader } - parsedConfig := config.DefaultConfig - if err := rawConfig.Unpack(&parsedConfig); err != nil { - return nil, fmt.Errorf("error reading config file: %w", err) - } limit := parsedConfig.Scheduler.Limit - locationName := parsedConfig.Scheduler.Location - if locationName == "" { - locationName = "Local" + schedLocationName := parsedConfig.Scheduler.Location + if schedLocationName == "" { + schedLocationName = "Local" } - location, err := time.LoadLocation(locationName) + location, err := time.LoadLocation(schedLocationName) if err != nil { return nil, err } diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader.go b/heartbeat/monitors/wrappers/monitorstate/esloader.go index 0f68e6d302b8..f51242fa6d3b 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader.go @@ -27,33 +27,46 @@ import ( "github.com/elastic/go-elasticsearch/v8" "github.com/elastic/go-elasticsearch/v8/esapi" + "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/esutil" + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" ) -func MakeESLoader(esc *elasticsearch.Client, indexPattern string) StateLoader { +func MakeESLoader(esc *elasticsearch.Client, indexPattern string, beatLocation *config.LocationWithID) StateLoader { if indexPattern == "" { // Should never happen, but if we ever make a coding error... logp.L().Warn("ES state loader initialized with no index pattern, will not load states from ES") return NilStateLoader } - return func(monitorId string) (*State, error) { + return func(sf stdfields.StdMonitorFields) (*State, error) { + queryMustClauses := []mapstr.M{ + { + "match": mapstr.M{"monitor.id": sf.ID}, + }, + { + "match": mapstr.M{"monitor.type": sf.Type}, + }, + { + "exists": mapstr.M{"field": "state"}, + }, + { + // Only search the past 6h of data for perf, otherwise we reset the state + // Monitors should run more frequently than that. + "range": mapstr.M{"@timestamp": mapstr.M{"gt": "now-6h"}}, + }, + } + + if sf.Location != nil { + queryMustClauses = append(queryMustClauses, mapstr.M{ + "match": mapstr.M{"observer.name": sf.Location.ID}, + }) + } + reqBody, err := json.Marshal(mapstr.M{ "sort": mapstr.M{"@timestamp": "desc"}, "query": mapstr.M{ "bool": mapstr.M{ - "must": []mapstr.M{ - { - "match": mapstr.M{"monitor.id": monitorId}, - }, - { - "exists": mapstr.M{"field": "state"}, - }, - { - // Only search the past 6h of data for perf, otherwise we reset the state - // Monitors should run more frequently than that. - "range": mapstr.M{"@timestamp": mapstr.M{"gt": "now-6h"}}, - }, - }, + "must": queryMustClauses, }, }, }) @@ -81,17 +94,17 @@ func MakeESLoader(esc *elasticsearch.Client, indexPattern string) StateLoader { respBody, err := esutil.CheckRetResp(r, err) if err != nil { - return nil, fmt.Errorf("error executing state search for %s: %w", monitorId, err) + return nil, fmt.Errorf("error executing state search for %s: %w", sf.ID, err) } sh := stateHits{} err = json.Unmarshal(respBody, &sh) if err != nil { - return nil, fmt.Errorf("could not unmarshal state hits for %s: %w", monitorId, err) + return nil, fmt.Errorf("could not unmarshal state hits for %s: %w", sf.ID, err) } if len(sh.Hits.Hits) == 0 { - logp.L().Infof("no previous state found for monitor %s", monitorId) + logp.L().Infof("no previous state found for monitor %s", sf.ID) return nil, nil } diff --git a/heartbeat/monitors/wrappers/monitorstate/helpers_test.go b/heartbeat/monitors/wrappers/monitorstate/helpers_test.go new file mode 100644 index 000000000000..310c50b26242 --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/helpers_test.go @@ -0,0 +1,5 @@ +package monitorstate + +import "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" + +var TestSf stdfields.StdMonitorFields = stdfields.StdMonitorFields{ID: "testID", Type: "testType"} diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 79f20e4d888b..f60b5f761d80 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -20,6 +20,8 @@ package monitorstate import ( "fmt" "time" + + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" ) // FlappingThreshold defines how many consecutive checks with the same status @@ -36,19 +38,19 @@ const ( StatusFlapping StateStatus = "flap" ) -func newMonitorState(monitorId string, status StateStatus, ctr int) *State { +func newMonitorState(sf stdfields.StdMonitorFields, status StateStatus, ctr int) *State { now := time.Now() ms := &State{ // ID is unique and sortable by time for easier aggregations // Note that we add an incrementing counter to help with the fact that // millisecond res isn't quite enough for uniqueness (esp. in tests) - ID: fmt.Sprintf("%s-%x-%x", monitorId, now.UnixMilli(), ctr), + ID: fmt.Sprintf("%s-%s-%x-%x", sf.ID, sf.Location, now.UnixMilli(), ctr), StartedAt: now, DurationMs: 0, Status: status, ctr: ctr + 1, } - ms.recordCheck(monitorId, status) + ms.recordCheck(sf, status) return ms } @@ -99,7 +101,7 @@ func (s *State) truncateFlapHistory() { // If the current state is continued it just updates counters and other record keeping, // if the state ends it actually swaps out the full value the state points to // and sets state.Ends. -func (s *State) recordCheck(monitorID string, newStatus StateStatus) { +func (s *State) recordCheck(sf stdfields.StdMonitorFields, newStatus StateStatus) { if s.Status == StatusFlapping { s.truncateFlapHistory() @@ -117,7 +119,7 @@ func (s *State) recordCheck(monitorID string, newStatus StateStatus) { s.FlapHistory = append(s.FlapHistory, newStatus) s.incrementCounters(newStatus) } else { // flap has ended - s.transitionTo(monitorID, newStatus) + s.transitionTo(sf, newStatus) } } else if s.Status == newStatus { // stable state, status has not changed // The state is stable, no changes needed @@ -128,7 +130,7 @@ func (s *State) recordCheck(monitorID string, newStatus StateStatus) { s.Status = StatusFlapping s.FlapHistory = append(s.FlapHistory, newStatus) } else { - s.transitionTo(monitorID, newStatus) + s.transitionTo(sf, newStatus) } // Ensure that the ends field is set to nil @@ -138,11 +140,11 @@ func (s *State) recordCheck(monitorID string, newStatus StateStatus) { } } -func (s *State) transitionTo(monitorID string, newStatus StateStatus) { +func (s *State) transitionTo(sf stdfields.StdMonitorFields, newStatus StateStatus) { // state has changed, but we aren't flapping (yet), since we've been stable past the // flapping threshold oldState := *s - *s = *newMonitorState(monitorID, newStatus, s.ctr) + *s = *newMonitorState(sf, newStatus, s.ctr) // We don't need to retain extra data when transitioning oldState.FlapHistory = nil // W edon't want an infinite linked list! diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index 7775878f7b7c..e3c0e2d0e424 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -21,18 +21,18 @@ import ( "testing" "time" + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/stretchr/testify/require" ) func TestRecordingAndFlapping(t *testing.T) { - monitorID := "test" - ms := newMonitorState(monitorID, StatusUp, 0) - recordFlappingSeries(monitorID, ms) + ms := newMonitorState(TestSf, StatusUp, 0) + recordFlappingSeries(TestSf, ms) require.Equal(t, StatusFlapping, ms.Status) require.Equal(t, FlappingThreshold+1, ms.Checks) require.Equal(t, ms.Up+ms.Down, ms.Checks) - recordStableSeries(monitorID, ms, FlappingThreshold*2, StatusDown) + recordStableSeries(TestSf, ms, FlappingThreshold*2, StatusDown) require.Equal(t, StatusDown, ms.Status) // The count should be FlappingThreshold+1 since we used double the threshold before // This is because we have one full threshold of stable checks, as well as the final check that @@ -41,46 +41,44 @@ func TestRecordingAndFlapping(t *testing.T) { require.Nil(t, ms.Ends, "expected nil ends after a stable series") // Since we're now in a stable state a single up check should create a new state from a stable one - ms.recordCheck(monitorID, StatusUp) + ms.recordCheck(TestSf, StatusUp) require.Equal(t, StatusUp, ms.Status) requireMSCounts(t, ms, 1, 0) } func TestDuration(t *testing.T) { - monitorID := "test" - ms := newMonitorState(monitorID, StatusUp, 0) - ms.recordCheck(monitorID, StatusUp) + ms := newMonitorState(TestSf, StatusUp, 0) + ms.recordCheck(TestSf, StatusUp) time.Sleep(time.Millisecond * 10) - ms.recordCheck(monitorID, StatusUp) + ms.recordCheck(TestSf, StatusUp) // Pretty forgiving upper bound to account for flaky CI require.True(t, ms.DurationMs > 9 && ms.DurationMs < 300, "Expected duration to be ~10ms, got %d", ms.DurationMs) } // recordFlappingSeries is a helper that should always put the monitor into a flapping state. -func recordFlappingSeries(monitorID string, ms *State) { +func recordFlappingSeries(TestSf stdfields.StdMonitorFields, ms *State) { for i := 0; i < FlappingThreshold; i++ { if i%2 == 0 { - ms.recordCheck(monitorID, StatusUp) + ms.recordCheck(TestSf, StatusUp) } else { - ms.recordCheck(monitorID, StatusDown) + ms.recordCheck(TestSf, StatusDown) } } } // recordStableSeries is a test helper for repeatedly recording one status -func recordStableSeries(monitorID string, ms *State, count int, s StateStatus) { +func recordStableSeries(TestSf stdfields.StdMonitorFields, ms *State, count int, s StateStatus) { for i := 0; i < count; i++ { - ms.recordCheck(monitorID, s) + ms.recordCheck(TestSf, s) } } func TestTransitionTo(t *testing.T) { - id := "mymonitor" - s := newMonitorState(id, StatusUp, 0) + s := newMonitorState(TestSf, StatusUp, 0) first := *s - s.transitionTo(id, StatusDown) + s.transitionTo(TestSf, StatusDown) second := *s - s.transitionTo(id, StatusUp) + s.transitionTo(TestSf, StatusUp) require.NotEqual(t, s.ID, second.ID) require.NotEqual(t, s.ID, first) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 82887e568a7f..35773fd9eb82 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -22,6 +22,7 @@ import ( "sync" "time" + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/elastic-agent-libs/logp" ) @@ -49,27 +50,27 @@ type Tracker struct { // StateLoader has signature as loadLastESState, useful for test mocking, and maybe for a future impl // other than ES if necessary -type StateLoader func(monitorID string) (*State, error) +type StateLoader func(stdfields.StdMonitorFields) (*State, error) -func (t *Tracker) RecordStatus(monitorID string, newStatus StateStatus) (ms *State) { +func (t *Tracker) RecordStatus(sf stdfields.StdMonitorFields, newStatus StateStatus) (ms *State) { //note: the return values have no concurrency controls, they may be unsafely read unless //copied to the stack, copying the structs before returning t.mtx.Lock() defer t.mtx.Unlock() - state := t.getCurrentState(monitorID) + state := t.getCurrentState(sf) if state == nil { - state = newMonitorState(monitorID, newStatus, 0) - t.states[monitorID] = state + state = newMonitorState(sf, newStatus, 0) + t.states[sf.ID] = state } else { - state.recordCheck(monitorID, newStatus) + state.recordCheck(sf, newStatus) } // return a copy since the state itself is a pointer that is frequently mutated return state.copy() } -func (t *Tracker) getCurrentState(monitorID string) (state *State) { - if state, ok := t.states[monitorID]; ok { +func (t *Tracker) getCurrentState(sf stdfields.StdMonitorFields) (state *State) { + if state, ok := t.states[sf.ID]; ok { return state } @@ -77,7 +78,7 @@ func (t *Tracker) getCurrentState(monitorID string) (state *State) { var loadedState *State var err error for i := 0; i < tries; i++ { - loadedState, err = t.stateLoader(monitorID) + loadedState, err = t.stateLoader(sf) if err != nil { sleepFor := (time.Duration(i*i) * time.Second) + (time.Duration(rand.Intn(500)) * time.Millisecond) logp.L().Warnf("could not load last externally recorded state, will retry again in %d milliseconds: %w", sleepFor.Milliseconds(), err) @@ -85,11 +86,11 @@ func (t *Tracker) getCurrentState(monitorID string) (state *State) { } } if err != nil { - logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, monitorID) + logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, sf.ID) } if loadedState != nil { - t.states[monitorID] = loadedState + t.states[sf.ID] = loadedState } // Return what we found, even if nil @@ -98,6 +99,6 @@ func (t *Tracker) getCurrentState(monitorID string) (state *State) { // NilStateLoader always returns nil, nil. It's the default when no ES conn is available // or during testing -func NilStateLoader(_ string) (*State, error) { +func NilStateLoader(_ stdfields.StdMonitorFields) (*State, error) { return nil, nil } diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index 5ea049b11f46..4f81d808ae22 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -24,19 +24,18 @@ import ( ) func TestTrackerRecord(t *testing.T) { - monId := "mymonitor" mst := NewTracker(NilStateLoader) - ms := mst.RecordStatus(monId, StatusUp) + ms := mst.RecordStatus(TestSf, StatusUp) require.Equal(t, StatusUp, ms.Status) requireMSStatusCount(t, ms, StatusUp, 1) for i := 0; i < FlappingThreshold; i++ { - ms = mst.RecordStatus(monId, StatusUp) + ms = mst.RecordStatus(TestSf, StatusUp) } require.Equal(t, StatusUp, ms.Status) requireMSCounts(t, ms, FlappingThreshold+1, 0) - ms = mst.RecordStatus(monId, StatusDown) + ms = mst.RecordStatus(TestSf, StatusDown) require.Equal(t, StatusDown, ms.Status) requireMSStatusCount(t, ms, StatusDown, 1) } diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index 0b1fffd6e4eb..f22384eda1f0 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -102,7 +102,7 @@ func addMonitorState(sf stdfields.StdMonitorFields, mst *monitorstate.Tracker) j return nil, fmt.Errorf("could not wrap state for '%s', no status assigned: %w", sf.ID, err) } - ms := mst.RecordStatus(sf.ID, monitorstate.StateStatus(status.(string))) + ms := mst.RecordStatus(sf, monitorstate.StateStatus(status.(string))) eventext.MergeEventFields(event, mapstr.M{"state": ms}) diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 6acf247169bb..2e6f01550c89 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -21,6 +21,7 @@ import ( "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/elastic-agent-libs/monitoring" + hbconfig "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/monitors" "github.com/elastic/beats/v7/heartbeat/scheduler" "github.com/elastic/beats/v7/libbeat/beat" @@ -31,10 +32,11 @@ import ( type ScenarioRun func() (config mapstr.M, close func(), err error) type Scenario struct { - Name string - Type string - Runner ScenarioRun - Tags []string + Name string + Type string + Runner ScenarioRun + Tags []string + Location *hbconfig.LocationWithID } func (s Scenario) Run(t *testing.T, callback func(mtr *MonitorTestRun, err error)) { @@ -47,7 +49,7 @@ func (s Scenario) Run(t *testing.T, callback func(mtr *MonitorTestRun, err error t.Run(s.Name, func(t *testing.T) { t.Parallel() - mtr, err := runMonitorOnce(t, cfgMap) + mtr, err := runMonitorOnce(t, cfgMap, s.Location) mtr.Wait() callback(mtr, err) mtr.Close() @@ -109,7 +111,7 @@ type MonitorTestRun struct { Close func() } -func runMonitorOnce(t *testing.T, monitorConfig mapstr.M) (mtr *MonitorTestRun, err error) { +func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.LocationWithID) (mtr *MonitorTestRun, err error) { mtr = &MonitorTestRun{ Config: monitorConfig, StdFields: stdfields.StdMonitorFields{}, @@ -118,7 +120,7 @@ func runMonitorOnce(t *testing.T, monitorConfig mapstr.M) (mtr *MonitorTestRun, // make a pipeline pipe := &monitors.MockPipeline{} // pass it to the factory - f, sched, closeFactory := setupFactoryAndSched() + f, sched, closeFactory := setupFactoryAndSched(location) conf, err := config.NewConfigFrom(monitorConfig) require.NoError(t, err) err = conf.Unpack(&mtr.StdFields) @@ -143,7 +145,7 @@ func runMonitorOnce(t *testing.T, monitorConfig mapstr.M) (mtr *MonitorTestRun, return mtr, err } -func setupFactoryAndSched() (factory *monitors.RunnerFactory, sched *scheduler.Scheduler, close func()) { +func setupFactoryAndSched(location *hbconfig.LocationWithID) (factory *monitors.RunnerFactory, sched *scheduler.Scheduler, close func()) { id, _ := uuid.NewV4() eid, _ := uuid.NewV4() info := beat.Info{ @@ -181,6 +183,7 @@ func setupFactoryAndSched() (factory *monitors.RunnerFactory, sched *scheduler.S c, _ := pipeline.Connect() return monitors.SyncPipelineClientAdaptor{C: c}, nil }, + BeatLocation: location, }), sched, sched.Stop From 73b435d20545b93795d0a991f7bc951324aa9df9 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 29 Aug 2022 18:13:38 -0500 Subject: [PATCH 079/102] FMT --- heartbeat/config/config.go | 2 +- heartbeat/monitors/stdfields/stdfields.go | 2 +- .../wrappers/monitorstate/helpers_test.go | 17 +++++++++++++++++ .../wrappers/monitorstate/monitorstate_test.go | 3 ++- 4 files changed, 21 insertions(+), 3 deletions(-) diff --git a/heartbeat/config/config.go b/heartbeat/config/config.go index e3950cd66152..0acbd0f56f32 100644 --- a/heartbeat/config/config.go +++ b/heartbeat/config/config.go @@ -39,7 +39,7 @@ type Config struct { Scheduler Scheduler `config:"scheduler"` Autodiscover *autodiscover.Config `config:"autodiscover"` Jobs map[string]*JobLimit `config:"jobs"` - Location *LocationWithID `config:"location` + Location *LocationWithID `config:"location"` } type JobLimit struct { diff --git a/heartbeat/monitors/stdfields/stdfields.go b/heartbeat/monitors/stdfields/stdfields.go index 7a8d0a5cf4bb..d709052a04d9 100644 --- a/heartbeat/monitors/stdfields/stdfields.go +++ b/heartbeat/monitors/stdfields/stdfields.go @@ -50,7 +50,7 @@ type StdMonitorFields struct { ZipUrl *config.C `config:"zip_url"` Local *config.C `config:"local"` } `config:"source"` - Location *hbconfig.LocationWithID `location` + Location *hbconfig.LocationWithID `config:"location"` } func ConfigToStdMonitorFields(conf *config.C) (StdMonitorFields, error) { diff --git a/heartbeat/monitors/wrappers/monitorstate/helpers_test.go b/heartbeat/monitors/wrappers/monitorstate/helpers_test.go index 310c50b26242..c30491c74dc4 100644 --- a/heartbeat/monitors/wrappers/monitorstate/helpers_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/helpers_test.go @@ -1,3 +1,20 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index e3c0e2d0e424..a177ba793c1d 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -21,8 +21,9 @@ import ( "testing" "time" - "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/stretchr/testify/require" + + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" ) func TestRecordingAndFlapping(t *testing.T) { From 315b1cf509e18bbfa6d8038e3bc68aac6001c303 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 29 Aug 2022 21:29:07 -0500 Subject: [PATCH 080/102] Disable flapping by default, add tests for this --- .../wrappers/monitorstate/monitorstate.go | 22 +++++++------- .../monitorstate/monitorstate_test.go | 6 ++-- .../monitors/wrappers/monitorstate/tracker.go | 18 ++++++----- .../wrappers/monitorstate/tracker_test.go | 30 +++++++++++++++++-- .../wrappers/monitorstate/util_test.go | 6 ++-- heartbeat/monitors/wrappers/wrappers.go | 3 +- 6 files changed, 58 insertions(+), 27 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index f60b5f761d80..ca7371693a17 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -38,17 +38,18 @@ const ( StatusFlapping StateStatus = "flap" ) -func newMonitorState(sf stdfields.StdMonitorFields, status StateStatus, ctr int) *State { +func newMonitorState(sf stdfields.StdMonitorFields, status StateStatus, ctr int, flappingEnabled bool) *State { now := time.Now() ms := &State{ // ID is unique and sortable by time for easier aggregations // Note that we add an incrementing counter to help with the fact that // millisecond res isn't quite enough for uniqueness (esp. in tests) - ID: fmt.Sprintf("%s-%s-%x-%x", sf.ID, sf.Location, now.UnixMilli(), ctr), - StartedAt: now, - DurationMs: 0, - Status: status, - ctr: ctr + 1, + ID: fmt.Sprintf("%s-%s-%x-%x", sf.ID, sf.Location, now.UnixMilli(), ctr), + StartedAt: now, + DurationMs: 0, + Status: status, + flappingEnabled: flappingEnabled, + ctr: ctr + 1, } ms.recordCheck(sf, status) @@ -68,8 +69,9 @@ type State struct { // computation if loading from ES or another source FlapHistory []StateStatus `json:"flap_history"` // Ends is a pointer to the prior state if this is the start of a new state - Ends *State `json:"ends"` - ctr int + Ends *State `json:"ends"` + flappingEnabled bool + ctr int } func (s *State) incrementCounters(status StateStatus) { @@ -124,7 +126,7 @@ func (s *State) recordCheck(sf stdfields.StdMonitorFields, newStatus StateStatus } else if s.Status == newStatus { // stable state, status has not changed // The state is stable, no changes needed s.incrementCounters(newStatus) - } else if s.Checks < FlappingThreshold { + } else if s.Checks < FlappingThreshold && s.flappingEnabled { // The state changed too quickly, we're now flapping s.incrementCounters(newStatus) s.Status = StatusFlapping @@ -144,7 +146,7 @@ func (s *State) transitionTo(sf stdfields.StdMonitorFields, newStatus StateStatu // state has changed, but we aren't flapping (yet), since we've been stable past the // flapping threshold oldState := *s - *s = *newMonitorState(sf, newStatus, s.ctr) + *s = *newMonitorState(sf, newStatus, s.ctr, s.flappingEnabled) // We don't need to retain extra data when transitioning oldState.FlapHistory = nil // W edon't want an infinite linked list! diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index a177ba793c1d..d8e616e2af25 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -27,7 +27,7 @@ import ( ) func TestRecordingAndFlapping(t *testing.T) { - ms := newMonitorState(TestSf, StatusUp, 0) + ms := newMonitorState(TestSf, StatusUp, 0, true) recordFlappingSeries(TestSf, ms) require.Equal(t, StatusFlapping, ms.Status) require.Equal(t, FlappingThreshold+1, ms.Checks) @@ -48,7 +48,7 @@ func TestRecordingAndFlapping(t *testing.T) { } func TestDuration(t *testing.T) { - ms := newMonitorState(TestSf, StatusUp, 0) + ms := newMonitorState(TestSf, StatusUp, 0, true) ms.recordCheck(TestSf, StatusUp) time.Sleep(time.Millisecond * 10) ms.recordCheck(TestSf, StatusUp) @@ -75,7 +75,7 @@ func recordStableSeries(TestSf stdfields.StdMonitorFields, ms *State, count int, } func TestTransitionTo(t *testing.T) { - s := newMonitorState(TestSf, StatusUp, 0) + s := newMonitorState(TestSf, StatusUp, 0, true) first := *s s.transitionTo(TestSf, StatusDown) second := *s diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 35773fd9eb82..53ebb708b714 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -31,21 +31,23 @@ import ( // before seen monitor, which usually means using ES. If set to nil // it will use ES if configured, otherwise it will only track state from // memory. -func NewTracker(sl StateLoader) *Tracker { +func NewTracker(sl StateLoader, flappingEnabled bool) *Tracker { if sl == nil { sl = NilStateLoader } return &Tracker{ - states: map[string]*State{}, - mtx: sync.Mutex{}, - stateLoader: sl, + states: map[string]*State{}, + mtx: sync.Mutex{}, + stateLoader: sl, + flappingEnabled: flappingEnabled, } } type Tracker struct { - states map[string]*State - mtx sync.Mutex - stateLoader StateLoader + states map[string]*State + mtx sync.Mutex + stateLoader StateLoader + flappingEnabled bool } // StateLoader has signature as loadLastESState, useful for test mocking, and maybe for a future impl @@ -60,7 +62,7 @@ func (t *Tracker) RecordStatus(sf stdfields.StdMonitorFields, newStatus StateSta state := t.getCurrentState(sf) if state == nil { - state = newMonitorState(sf, newStatus, 0) + state = newMonitorState(sf, newStatus, 0, t.flappingEnabled) t.states[sf.ID] = state } else { state.recordCheck(sf, newStatus) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go index 4f81d808ae22..14a9a34c12dc 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker_test.go @@ -24,16 +24,42 @@ import ( ) func TestTrackerRecord(t *testing.T) { - mst := NewTracker(NilStateLoader) + mst := NewTracker(NilStateLoader, true) ms := mst.RecordStatus(TestSf, StatusUp) require.Equal(t, StatusUp, ms.Status) requireMSStatusCount(t, ms, StatusUp, 1) for i := 0; i < FlappingThreshold; i++ { + _ = mst.RecordStatus(TestSf, StatusDown) ms = mst.RecordStatus(TestSf, StatusUp) } + require.Equal(t, StatusFlapping, ms.Status) + requireMSCounts(t, ms, FlappingThreshold+1, FlappingThreshold) + + // Restore stable state + for i := 0; i < FlappingThreshold; i++ { + _ = mst.RecordStatus(TestSf, StatusDown) + } + + ms = mst.RecordStatus(TestSf, StatusDown) + require.Equal(t, StatusDown, ms.Status) + requireMSStatusCount(t, ms, StatusDown, FlappingThreshold-1) +} + +func TestTrackerRecordFlappingDisabled(t *testing.T) { + mst := NewTracker(NilStateLoader, false) + ms := mst.RecordStatus(TestSf, StatusUp) + require.Equal(t, StatusUp, ms.Status) + requireMSStatusCount(t, ms, StatusUp, 1) + + for i := 0; i < FlappingThreshold; i++ { + _ = mst.RecordStatus(TestSf, StatusDown) + ms = mst.RecordStatus(TestSf, StatusUp) + } + + // with flapping disabled it only shows as up require.Equal(t, StatusUp, ms.Status) - requireMSCounts(t, ms, FlappingThreshold+1, 0) + requireMSCounts(t, ms, 1, 0) ms = mst.RecordStatus(TestSf, StatusDown) require.Equal(t, StatusDown, ms.Status) diff --git a/heartbeat/monitors/wrappers/monitorstate/util_test.go b/heartbeat/monitors/wrappers/monitorstate/util_test.go index 09e5d3263557..f3576bee49a8 100644 --- a/heartbeat/monitors/wrappers/monitorstate/util_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/util_test.go @@ -34,7 +34,7 @@ func requireMSStatusCount(t *testing.T, ms *State, status StateStatus, count int } func requireMSCounts(t *testing.T, ms *State, up int, down int) { - require.Equal(t, up+down, ms.Checks) - require.Equal(t, up, ms.Up) - require.Equal(t, down, ms.Down) + require.Equal(t, up+down, ms.Checks, "expected %d total checks, got %d (%d up / %d down)", up+down, ms.Checks, ms.Up, ms.Down) + require.Equal(t, up, ms.Up, "expected %d up checks, got %d", up, ms.Up) + require.Equal(t, down, ms.Down, "expected %d down checks, got %d", down, ms.Down) } diff --git a/heartbeat/monitors/wrappers/wrappers.go b/heartbeat/monitors/wrappers/wrappers.go index f22384eda1f0..bdc5935ae3b9 100644 --- a/heartbeat/monitors/wrappers/wrappers.go +++ b/heartbeat/monitors/wrappers/wrappers.go @@ -42,7 +42,8 @@ import ( // WrapCommon applies the common wrappers that all monitor jobs get. func WrapCommon(js []jobs.Job, stdMonFields stdfields.StdMonitorFields, stateLoader monitorstate.StateLoader) []jobs.Job { - mst := monitorstate.NewTracker(stateLoader) + // flapping is disabled by default until we sort out how it should work + mst := monitorstate.NewTracker(stateLoader, false) if stdMonFields.Type == "browser" { return WrapBrowser(js, stdMonFields, mst) } else { From 305c837c752f55160db20091d7801f00a954a710 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 29 Aug 2022 21:55:58 -0500 Subject: [PATCH 081/102] Fix broken integ tests, refactor integ framework --- .../wrappers/monitorstate/esloader_test.go | 36 +++++++++++++------ x-pack/heartbeat/scenarios/framework.go | 4 +++ x-pack/heartbeat/scenarios/scenarios.go | 16 +++++---- 3 files changed, 39 insertions(+), 17 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_test.go index 59fd375e1c56..34d6b6b11bc6 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_test.go @@ -31,7 +31,10 @@ import ( "github.com/elastic/go-elasticsearch/v8" "github.com/elastic/go-elasticsearch/v8/esapi" + "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/esutil" + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" + "github.com/elastic/beats/v7/libbeat/processors/util" ) func TestStatesESLoader(t *testing.T) { @@ -92,33 +95,44 @@ type esTestContext struct { esc *elasticsearch.Client loader StateLoader tracker *Tracker + location *config.LocationWithID } func newESTestContext(t *testing.T) *esTestContext { + location := &config.LocationWithID{ + ID: "TestId", + Geo: util.GeoConfig{ + Name: "TestGeoName", + }, + } namespace, _ := uuid.NewV4() esc := integES(t) etc := &esTestContext{ namespace: namespace.String(), esc: esc, - loader: MakeESLoader(esc, fmt.Sprintf("synthetics-*-%s", namespace.String())), + loader: MakeESLoader(esc, fmt.Sprintf("synthetics-*-%s", namespace.String()), location), + location: location, } - etc.tracker = NewTracker(etc.loader) + etc.tracker = NewTracker(etc.loader, true) return etc } -func (etc *esTestContext) createTestMonitorStateInES(t *testing.T, s StateStatus) (id string) { +func (etc *esTestContext) createTestMonitorStateInES(t *testing.T, s StateStatus) (sf stdfields.StdMonitorFields) { mUUID, _ := uuid.NewV4() - mID := mUUID.String() - mType := "testtyp" - initState := newMonitorState(mID, s, 0) - etc.setInitialState(t, mType, mID, initState) - return mID + sf = stdfields.StdMonitorFields{ + ID: mUUID.String(), + Type: "test_type", + } + + initState := newMonitorState(sf, s, 0, true) + etc.setInitialState(t, sf, initState) + return sf } -func (etc *esTestContext) setInitialState(t *testing.T, typ string, monitorID string, ms *State) { - idx := fmt.Sprintf("synthetics-%s-%s", typ, etc.namespace) +func (etc *esTestContext) setInitialState(t *testing.T, sf stdfields.StdMonitorFields, ms *State) { + idx := fmt.Sprintf("synthetics-%s-%s", sf.Type, etc.namespace) type Mon struct { Id string `json:"id"` @@ -131,7 +145,7 @@ func (etc *esTestContext) setInitialState(t *testing.T, typ string, monitorID st State *State `json:"state"` }{ Ts: time.Now(), - Monitor: Mon{Id: monitorID, Type: typ}, + Monitor: Mon{Id: sf.ID, Type: sf.Type}, State: ms, }) require.NoError(t, err) diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 2e6f01550c89..390730c0ee1c 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -85,6 +85,10 @@ func (sdb *ScenarioDB) Init() { sdb.All = prunedList } +func (sdb *ScenarioDB) Add(s ...Scenario) { + sdb.All = append(sdb.All, s...) +} + func (sdb *ScenarioDB) RunAll(t *testing.T, callback func(*MonitorTestRun, error)) { sdb.Init() for _, s := range sdb.All { diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index f4474643cc44..cb3ea6b71fa5 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -19,8 +19,12 @@ import ( var Scenarios = &ScenarioDB{ initOnce: &sync.Once{}, ByTag: map[string][]Scenario{}, - All: []Scenario{ - { + All: []Scenario{}, +} + +func init() { + Scenarios.Add( + Scenario{ Name: "http-simple", Type: "http", Tags: []string{"lightweight", "http"}, @@ -36,7 +40,7 @@ var Scenarios = &ScenarioDB{ return config, server.Close, nil }, }, - { + Scenario{ Name: "tcp-simple", Type: "tcp", Tags: []string{"lightweight", "tcp"}, @@ -56,7 +60,7 @@ var Scenarios = &ScenarioDB{ return config, server.Close, nil }, }, - { + Scenario{ Name: "simple-icmp", Type: "icmp", Tags: []string{"icmp"}, @@ -70,7 +74,7 @@ var Scenarios = &ScenarioDB{ }, func() {}, nil }, }, - { + Scenario{ Name: "simple-browser", Type: "browser", Tags: []string{"browser", "browser-inline"}, @@ -95,5 +99,5 @@ var Scenarios = &ScenarioDB{ return config, server.Close, nil }, }, - }, + ) } From a27c7eca3524349d6ec191c5ecf9bc946cc675c0 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 15:02:03 -0500 Subject: [PATCH 082/102] Initial work for scenario tests with ES --- .../wrappers/monitorstate/esloader_test.go | 26 +----- .../wrappers/monitorstate/testutil.go | 38 ++++++++ x-pack/heartbeat/scenarios/README.md | 16 ++++ x-pack/heartbeat/scenarios/basics_test.go | 6 +- .../scenarios/es_integration_test.go | 14 ++- x-pack/heartbeat/scenarios/framework.go | 88 ++++++++++++++----- x-pack/heartbeat/scenarios/framework_test.go | 42 +++++++++ x-pack/heartbeat/scenarios/scenarios.go | 52 ++++++++--- x-pack/heartbeat/scenarios/twists.go | 21 +++++ 9 files changed, 242 insertions(+), 61 deletions(-) create mode 100644 heartbeat/monitors/wrappers/monitorstate/testutil.go create mode 100644 x-pack/heartbeat/scenarios/README.md create mode 100644 x-pack/heartbeat/scenarios/framework_test.go create mode 100644 x-pack/heartbeat/scenarios/twists.go diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader_test.go b/heartbeat/monitors/wrappers/monitorstate/esloader_test.go index 34d6b6b11bc6..d3b318b6c4c7 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader_test.go @@ -20,7 +20,6 @@ package monitorstate import ( - "encoding/json" "fmt" "testing" "time" @@ -106,11 +105,11 @@ func newESTestContext(t *testing.T) *esTestContext { }, } namespace, _ := uuid.NewV4() - esc := integES(t) + esc := IntegES(t) etc := &esTestContext{ namespace: namespace.String(), esc: esc, - loader: MakeESLoader(esc, fmt.Sprintf("synthetics-*-%s", namespace.String()), location), + loader: IntegESLoader(t, fmt.Sprintf("synthetics-*-%s", namespace.String()), location), location: location, } @@ -157,24 +156,3 @@ func (etc *esTestContext) setInitialState(t *testing.T, sf stdfields.StdMonitorF })) require.NoError(t, err) } - -func integES(t *testing.T) (esc *elasticsearch.Client) { - esc, err := elasticsearch.NewClient(elasticsearch.Config{ - Addresses: []string{"http://127.0.0.1:9200"}, - Username: "admin", - Password: "testing", - }) - require.NoError(t, err) - respBody, err := esc.Cluster.Health() - healthRaw, err := esutil.CheckRetResp(respBody, err) - require.NoError(t, err) - - healthResp := struct { - Status string `json:"status"` - }{} - err = json.Unmarshal(healthRaw, &healthResp) - require.NoError(t, err) - require.Contains(t, []string{"green", "yellow"}, healthResp.Status) - - return esc -} diff --git a/heartbeat/monitors/wrappers/monitorstate/testutil.go b/heartbeat/monitors/wrappers/monitorstate/testutil.go new file mode 100644 index 000000000000..0ca05fdfb339 --- /dev/null +++ b/heartbeat/monitors/wrappers/monitorstate/testutil.go @@ -0,0 +1,38 @@ +package monitorstate + +import ( + "encoding/json" + "testing" + + "github.com/elastic/beats/v7/heartbeat/config" + "github.com/elastic/beats/v7/heartbeat/esutil" + "github.com/elastic/go-elasticsearch/v8" + "github.com/stretchr/testify/require" +) + +// Helpers for tests here and elsewhere + +func IntegESLoader(t *testing.T, indexPattern string, location *config.LocationWithID) StateLoader { + return MakeESLoader(IntegES(t), indexPattern, location) +} + +func IntegES(t *testing.T) (esc *elasticsearch.Client) { + esc, err := elasticsearch.NewClient(elasticsearch.Config{ + Addresses: []string{"http://127.0.0.1:9200"}, + Username: "admin", + Password: "testing", + }) + require.NoError(t, err) + respBody, err := esc.Cluster.Health() + healthRaw, err := esutil.CheckRetResp(respBody, err) + require.NoError(t, err) + + healthResp := struct { + Status string `json:"status"` + }{} + err = json.Unmarshal(healthRaw, &healthResp) + require.NoError(t, err) + require.Contains(t, []string{"green", "yellow"}, healthResp.Status) + + return esc +} diff --git a/x-pack/heartbeat/scenarios/README.md b/x-pack/heartbeat/scenarios/README.md new file mode 100644 index 000000000000..acc14d198fb4 --- /dev/null +++ b/x-pack/heartbeat/scenarios/README.md @@ -0,0 +1,16 @@ +## Test Scenarios & Framework for Heartbeat + +This directory contains only tests, and the framework used to run them. The tests are in `_test.go` files, with the +framework and scenario definitions contained in the regular `.go` files. + +The key types in here are: + +- Scenario: A description of a given heartbeat configuration with some additional parameters +- Twist: A way to modify a scenario, by adding one additional configuration parameter perhaps +- ScenarioDB: A database of all known scenarios that lets you easily gather the events created by a single run of each + +By using these three types you can create a complex matrix of tests to cover a lot of bases. + +The main idea here is decoupling the generation of test data from the testing of it, letting us test multiple criteria on +a known set of data. This can be thought of as an alternative to fixtures, where each `Scenario` could be thought of as a +dynamic fixture. \ No newline at end of file diff --git a/x-pack/heartbeat/scenarios/basics_test.go b/x-pack/heartbeat/scenarios/basics_test.go index 36e5abf77761..475a86ec7e75 100644 --- a/x-pack/heartbeat/scenarios/basics_test.go +++ b/x-pack/heartbeat/scenarios/basics_test.go @@ -21,7 +21,7 @@ import ( ) func TestSimpleScenariosBasicFields(t *testing.T) { - Scenarios.RunAll(t, func(mtr *MonitorTestRun, err error) { + Scenarios.RunAll(t, func(t *testing.T, mtr *MonitorTestRun, err error) { require.GreaterOrEqual(t, len(mtr.Events()), 1) lastCg := "" for i, e := range mtr.Events() { @@ -48,7 +48,7 @@ func TestSimpleScenariosBasicFields(t *testing.T) { } func TestLightweightUrls(t *testing.T) { - Scenarios.RunTag(t, "lightweight", func(mtr *MonitorTestRun, err error) { + Scenarios.RunTag(t, "lightweight", func(t *testing.T, mtr *MonitorTestRun, err error) { for _, e := range mtr.Events() { testslike.Test(t, lookslike.MustCompile(map[string]interface{}{ "url": map[string]interface{}{ @@ -62,7 +62,7 @@ func TestLightweightUrls(t *testing.T) { } func TestLightweightSummaries(t *testing.T) { - Scenarios.RunTag(t, "lightweight", func(mtr *MonitorTestRun, err error) { + Scenarios.RunTag(t, "lightweight", func(t *testing.T, mtr *MonitorTestRun, err error) { all := mtr.Events() lastEvent, firstEvents := all[len(all)-1], all[:len(all)-1] testslike.Test(t, lookslike.MustCompile(map[string]interface{}{ diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go index 0146e73b367a..beb42790d72f 100644 --- a/x-pack/heartbeat/scenarios/es_integration_test.go +++ b/x-pack/heartbeat/scenarios/es_integration_test.go @@ -6,8 +6,20 @@ package scenarios import ( "testing" + + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" + "github.com/stretchr/testify/require" ) -func TestStart(t *testing.T) { +func TestBlankState(t *testing.T) { + Scenarios.RunAllWithATwist(t, TwistAddLocation, func(t *testing.T, mtr *MonitorTestRun, err error) { + for _, e := range mtr.Events() { + if stateIface, _ := e.Fields.GetValue("state"); stateIface != nil { + state, ok := stateIface.(*monitorstate.State) + require.True(t, ok, "state is not a monitorstate.State, got %v", state) + require.Equal(t, monitorstate.StatusUp, state.Status) + } + } + }) } diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 390730c0ee1c..90ee6aa9a03d 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -5,6 +5,7 @@ package scenarios import ( + "fmt" "os" "sync" "testing" @@ -29,32 +30,63 @@ import ( beatversion "github.com/elastic/beats/v7/libbeat/version" ) -type ScenarioRun func() (config mapstr.M, close func(), err error) +type ScenarioRun func(t *testing.T) (config mapstr.M, close func(), err error) type Scenario struct { - Name string - Type string - Runner ScenarioRun - Tags []string - Location *hbconfig.LocationWithID + Name string + Type string + Runner ScenarioRun + Tags []string + Location *hbconfig.LocationWithID + ESEnabled bool } -func (s Scenario) Run(t *testing.T, callback func(mtr *MonitorTestRun, err error)) { - cfgMap, rClose, err := s.Runner() - defer rClose() +type Twist func(Scenario) Scenario + +func MakeTwist(name string, fn Twist) Twist { + return func(s Scenario) Scenario { + newS := s.clone() + newS.Name = fmt.Sprintf("%s>Twist(%s)", s.Name, name) + return fn(newS) + } +} + +func (s Scenario) clone() Scenario { + copy := s + if s.Location != nil { + locationCopy := *s.Location + copy.Location = &locationCopy + } + return copy +} + +func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr *MonitorTestRun, err error)) { + runS := s + if twist != nil { + runS = twist(s.clone()) + } + + cfgMap, rClose, err := runS.Runner(t) + if rClose != nil { + defer rClose() + } if err != nil { - callback(nil, err) + callback(t, nil, err) return } - t.Run(s.Name, func(t *testing.T) { + stateLoader := monitorstate.NilStateLoader + if s.ESEnabled { + stateLoader = monitorstate.IntegESLoader(t, "heartbeat-*,synthetics-*", TestLocationDefault) + } + + t.Run(runS.Name, func(t *testing.T) { t.Parallel() - mtr, err := runMonitorOnce(t, cfgMap, s.Location) + mtr, err := runMonitorOnce(t, cfgMap, runS.Location, stateLoader) mtr.Wait() - callback(mtr, err) + callback(t, mtr, err) mtr.Close() }) - } type ScenarioDB struct { @@ -89,20 +121,28 @@ func (sdb *ScenarioDB) Add(s ...Scenario) { sdb.All = append(sdb.All, s...) } -func (sdb *ScenarioDB) RunAll(t *testing.T, callback func(*MonitorTestRun, error)) { +func (sdb *ScenarioDB) RunAll(t *testing.T, callback func(*testing.T, *MonitorTestRun, error)) { + sdb.RunAllWithATwist(t, nil, callback) +} + +func (sdb *ScenarioDB) RunAllWithATwist(t *testing.T, twist Twist, callback func(*testing.T, *MonitorTestRun, error)) { sdb.Init() for _, s := range sdb.All { - s.Run(t, callback) + s.Run(t, twist, callback) } } -func (sdb *ScenarioDB) RunTag(t *testing.T, tagName string, callback func(*MonitorTestRun, error)) { +func (sdb *ScenarioDB) RunTag(t *testing.T, tagName string, callback func(*testing.T, *MonitorTestRun, error)) { + sdb.RunTagWithATwist(t, tagName, nil, callback) +} + +func (sdb *ScenarioDB) RunTagWithATwist(t *testing.T, tagName string, twist Twist, callback func(*testing.T, *MonitorTestRun, error)) { sdb.Init() if len(sdb.ByTag[tagName]) < 1 { require.Failf(t, "no scenarios have tags matching %s", tagName) } for _, s := range sdb.ByTag[tagName] { - s.Run(t, callback) + s.Run(t, twist, callback) } } @@ -115,7 +155,7 @@ type MonitorTestRun struct { Close func() } -func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.LocationWithID) (mtr *MonitorTestRun, err error) { +func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.LocationWithID, stateLoader monitorstate.StateLoader) (mtr *MonitorTestRun, err error) { mtr = &MonitorTestRun{ Config: monitorConfig, StdFields: stdfields.StdMonitorFields{}, @@ -124,7 +164,7 @@ func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.Loc // make a pipeline pipe := &monitors.MockPipeline{} // pass it to the factory - f, sched, closeFactory := setupFactoryAndSched(location) + f, sched, closeFactory := setupFactoryAndSched(location, stateLoader) conf, err := config.NewConfigFrom(monitorConfig) require.NoError(t, err) err = conf.Unpack(&mtr.StdFields) @@ -149,7 +189,7 @@ func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.Loc return mtr, err } -func setupFactoryAndSched(location *hbconfig.LocationWithID) (factory *monitors.RunnerFactory, sched *scheduler.Scheduler, close func()) { +func setupFactoryAndSched(location *hbconfig.LocationWithID, stateLoader monitorstate.StateLoader) (factory *monitors.RunnerFactory, sched *scheduler.Scheduler, close func()) { id, _ := uuid.NewV4() eid, _ := uuid.NewV4() info := beat.Info{ @@ -178,10 +218,14 @@ func setupFactoryAndSched(location *hbconfig.LocationWithID) (factory *monitors. true, ) + if stateLoader == nil { + stateLoader = monitorstate.NilStateLoader + } + return monitors.NewFactory(monitors.FactoryParams{ BeatInfo: info, AddTask: sched.Add, - StateLoader: monitorstate.NilStateLoader, + StateLoader: stateLoader, PluginsReg: plugin.GlobalPluginsReg, PipelineClientFactory: func(pipeline beat.Pipeline) (pipeline.ISyncClient, error) { c, _ := pipeline.Connect() diff --git a/x-pack/heartbeat/scenarios/framework_test.go b/x-pack/heartbeat/scenarios/framework_test.go new file mode 100644 index 000000000000..00dd79b59704 --- /dev/null +++ b/x-pack/heartbeat/scenarios/framework_test.go @@ -0,0 +1,42 @@ +package scenarios + +import ( + "testing" + + "github.com/elastic/beats/v7/heartbeat/config" + "github.com/elastic/beats/v7/libbeat/processors/util" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/stretchr/testify/require" +) + +var testScenario Scenario = Scenario{ + Name: "My Scenario", + Tags: []string{"testTag"}, + Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { + return mapstr.M{ + "type": "http", + "id": "testID", + "name": "testName", + "schedule": "@every 10s", + }, nil, nil + }, + Location: &config.LocationWithID{ + ID: "TestID", + Geo: util.GeoConfig{ + Name: "TestName", + }, + }, +} + +func TestClone(t *testing.T) { + clone := testScenario.clone() + clone.Name = "CloneName" + require.NotEqual(t, testScenario.Name, clone.Name) + clone.Tags = []string{"CloneTag"} + require.NotEqual(t, testScenario.Tags, clone.Tags) + clone.Location.ID = "CloneID" + require.NotEqual(t, testScenario.Location.ID, clone.Location.ID) + clone.Location.Geo.Name = "CloneGeoName" + require.NotEqual(t, testScenario.Location.Geo.Name, clone.Location.Geo.Name) + +} diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index cb3ea6b71fa5..54d5ed27a494 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -6,12 +6,16 @@ package scenarios import ( "fmt" + "net/http" "net/http/httptest" "net/url" "os" "sync" + "testing" + "time" "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/stretchr/testify/require" "github.com/elastic/beats/v7/heartbeat/hbtest" ) @@ -22,14 +26,40 @@ var Scenarios = &ScenarioDB{ All: []Scenario{}, } +var testWs *httptest.Server + +var testWsOnce = &sync.Once{} + +// Starting this thing up is expensive, let's just do it once +func startTestWebserver(t *testing.T) *httptest.Server { + testWsOnce.Do(func() { + testWs = httptest.NewServer(hbtest.HelloWorldHandler(200)) + var err error + for i := 0; i < 20; i++ { + var resp *http.Response + resp, err = http.Get(testWs.URL) + if err == nil && resp.StatusCode == 200 { + break + } + time.Sleep(time.Millisecond * 250) + } + + if err != nil { + require.NoError(t, err, "could not retrieve successful response from test webserver") + } + }) + + return testWs +} + func init() { Scenarios.Add( Scenario{ Name: "http-simple", Type: "http", Tags: []string{"lightweight", "http"}, - Runner: func() (config mapstr.M, close func(), err error) { - server := httptest.NewServer(hbtest.HelloWorldHandler(200)) + Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { + server := startTestWebserver(t) config = mapstr.M{ "id": "http-test-id", "name": "http-test-name", @@ -37,15 +67,15 @@ func init() { "schedule": "@every 1m", "urls": []string{server.URL}, } - return config, server.Close, nil + return config, nil, nil }, }, Scenario{ Name: "tcp-simple", Type: "tcp", Tags: []string{"lightweight", "tcp"}, - Runner: func() (config mapstr.M, close func(), err error) { - server := httptest.NewServer(hbtest.HelloWorldHandler(200)) + Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { + server := startTestWebserver(t) parsedUrl, err := url.Parse(server.URL) if err != nil { panic(fmt.Sprintf("URL %s should always be parsable: %s", server.URL, err)) @@ -55,16 +85,16 @@ func init() { "name": "tcp-test-name", "type": "tcp", "schedule": "@every 1m", - "hosts": []string{fmt.Sprintf("%s:%s", parsedUrl.Host, parsedUrl.Port())}, + "hosts": []string{parsedUrl.Host}, // Host includes host:port } - return config, server.Close, nil + return config, nil, nil }, }, Scenario{ Name: "simple-icmp", Type: "icmp", Tags: []string{"icmp"}, - Runner: func() (config mapstr.M, close func(), err error) { + Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { return mapstr.M{ "id": "icmp-test-id", "name": "icmp-test-name", @@ -78,12 +108,12 @@ func init() { Name: "simple-browser", Type: "browser", Tags: []string{"browser", "browser-inline"}, - Runner: func() (config mapstr.M, close func(), err error) { + Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { err = os.Setenv("ELASTIC_SYNTHETICS_CAPABLE", "true") if err != nil { return nil, nil, err } - server := httptest.NewServer(hbtest.HelloWorldHandler(200)) + server := startTestWebserver(t) config = mapstr.M{ "id": "browser-test-id", "name": "browser-test-name", @@ -96,7 +126,7 @@ func init() { }, }, } - return config, server.Close, nil + return config, nil, nil }, }, ) diff --git a/x-pack/heartbeat/scenarios/twists.go b/x-pack/heartbeat/scenarios/twists.go new file mode 100644 index 000000000000..7d18fc6a1da6 --- /dev/null +++ b/x-pack/heartbeat/scenarios/twists.go @@ -0,0 +1,21 @@ +package scenarios + +import ( + "github.com/elastic/beats/v7/heartbeat/config" + "github.com/elastic/beats/v7/libbeat/processors/util" +) + +var TestLocationDefault = TestLocationMpls + +var TestLocationMpls = &config.LocationWithID{ + ID: "na-mpls", + Geo: util.GeoConfig{ + Name: "Minneapolis", + Location: "44.9778, 93.2650", + }, +} + +var TwistAddLocation = MakeTwist("add location", func(s Scenario) Scenario { + s.Location = TestLocationDefault + return s +}) From 7f010b14a0a3e4835b56e0ad2aba52c1233bec4c Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 15:02:30 -0500 Subject: [PATCH 083/102] Format --- .../wrappers/monitorstate/testutil.go | 20 ++++++++++++++++++- .../scenarios/es_integration_test.go | 3 ++- x-pack/heartbeat/scenarios/framework_test.go | 7 ++++++- x-pack/heartbeat/scenarios/scenarios.go | 3 ++- x-pack/heartbeat/scenarios/twists.go | 4 ++++ 5 files changed, 33 insertions(+), 4 deletions(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/testutil.go b/heartbeat/monitors/wrappers/monitorstate/testutil.go index 0ca05fdfb339..2ec908c2cf93 100644 --- a/heartbeat/monitors/wrappers/monitorstate/testutil.go +++ b/heartbeat/monitors/wrappers/monitorstate/testutil.go @@ -1,13 +1,31 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + package monitorstate import ( "encoding/json" "testing" + "github.com/stretchr/testify/require" + "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/heartbeat/esutil" "github.com/elastic/go-elasticsearch/v8" - "github.com/stretchr/testify/require" ) // Helpers for tests here and elsewhere diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go index beb42790d72f..c0e43d745ad0 100644 --- a/x-pack/heartbeat/scenarios/es_integration_test.go +++ b/x-pack/heartbeat/scenarios/es_integration_test.go @@ -7,8 +7,9 @@ package scenarios import ( "testing" - "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" "github.com/stretchr/testify/require" + + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" ) func TestBlankState(t *testing.T) { diff --git a/x-pack/heartbeat/scenarios/framework_test.go b/x-pack/heartbeat/scenarios/framework_test.go index 00dd79b59704..2df107a8a99f 100644 --- a/x-pack/heartbeat/scenarios/framework_test.go +++ b/x-pack/heartbeat/scenarios/framework_test.go @@ -1,12 +1,17 @@ +// 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 scenarios import ( "testing" + "github.com/stretchr/testify/require" + "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/libbeat/processors/util" "github.com/elastic/elastic-agent-libs/mapstr" - "github.com/stretchr/testify/require" ) var testScenario Scenario = Scenario{ diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index 54d5ed27a494..1e37f75c95f8 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -14,9 +14,10 @@ import ( "testing" "time" - "github.com/elastic/elastic-agent-libs/mapstr" "github.com/stretchr/testify/require" + "github.com/elastic/elastic-agent-libs/mapstr" + "github.com/elastic/beats/v7/heartbeat/hbtest" ) diff --git a/x-pack/heartbeat/scenarios/twists.go b/x-pack/heartbeat/scenarios/twists.go index 7d18fc6a1da6..3b53176c3833 100644 --- a/x-pack/heartbeat/scenarios/twists.go +++ b/x-pack/heartbeat/scenarios/twists.go @@ -1,3 +1,7 @@ +// 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 scenarios import ( From eb0de76556eca691930e7bcece6a697bff7679fe Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 16:08:38 -0500 Subject: [PATCH 084/102] Checkpoint --- .../scenarios/es_integration_test.go | 43 +++++++++-- x-pack/heartbeat/scenarios/framework.go | 77 ++++++++++++++----- x-pack/heartbeat/scenarios/twists.go | 14 ++++ 3 files changed, 106 insertions(+), 28 deletions(-) diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go index c0e43d745ad0..4bda00296469 100644 --- a/x-pack/heartbeat/scenarios/es_integration_test.go +++ b/x-pack/heartbeat/scenarios/es_integration_test.go @@ -10,17 +10,44 @@ import ( "github.com/stretchr/testify/require" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" + "github.com/elastic/beats/v7/libbeat/beat" ) -func TestBlankState(t *testing.T) { - Scenarios.RunAllWithATwist(t, TwistAddLocation, func(t *testing.T, mtr *MonitorTestRun, err error) { - for _, e := range mtr.Events() { - if stateIface, _ := e.Fields.GetValue("state"); stateIface != nil { - state, ok := stateIface.(*monitorstate.State) - require.True(t, ok, "state is not a monitorstate.State, got %v", state) +type stateEvent struct { + event *beat.Event + state *monitorstate.State +} + +func allStates(t *testing.T, events []*beat.Event) (stateEvents []stateEvent) { + for _, e := range events { + if stateIface, _ := e.Fields.GetValue("state"); stateIface != nil { + state, ok := stateIface.(*monitorstate.State) + require.True(t, ok, "state is not a monitorstate.State, got %v", state) - require.Equal(t, monitorstate.StatusUp, state.Status) - } + se := stateEvent{event: e, state: state} + stateEvents = append(stateEvents, se) } + } + return stateEvents +} + +func lastState(t *testing.T, events []*beat.Event) stateEvent { + all := allStates(t, events) + require.NotEmpty(t, all) + return all[len(all)-1] +} + +var esIntegTwists = MultiTwist(TwistAddLocation, TwistMultiRun(3), TwistEnableES) + +func TestStateContinuity(t *testing.T) { + Scenarios.RunAllWithATwist(t, esIntegTwists, func(t *testing.T, mtr *MonitorTestRun, err error) { + lastSS := lastState(t, mtr.Events()) + + require.Equal(t, monitorstate.StatusUp, lastSS.state.Status) + + allSS := allStates(t, mtr.Events()) + require.Len(t, allSS, 3) + + require.Equal(t, 3, lastSS.state.Checks) }) } diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 90ee6aa9a03d..16238d25eb20 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -33,12 +33,13 @@ import ( type ScenarioRun func(t *testing.T) (config mapstr.M, close func(), err error) type Scenario struct { - Name string - Type string - Runner ScenarioRun - Tags []string - Location *hbconfig.LocationWithID - ESEnabled bool + Name string + Type string + Runner ScenarioRun + Tags []string + Location *hbconfig.LocationWithID + ESEnabled bool + NumberOfRuns int } type Twist func(Scenario) Scenario @@ -46,11 +47,21 @@ type Twist func(Scenario) Scenario func MakeTwist(name string, fn Twist) Twist { return func(s Scenario) Scenario { newS := s.clone() - newS.Name = fmt.Sprintf("%s>Twist(%s)", s.Name, name) + newS.Name = fmt.Sprintf("%s~<%s>", s.Name, name) return fn(newS) } } +func MultiTwist(twists ...Twist) Twist { + return func(s Scenario) Scenario { + res := s + for _, twist := range twists { + res = twist(res) + } + return res + } +} + func (s Scenario) clone() Scenario { copy := s if s.Location != nil { @@ -82,10 +93,36 @@ func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr t.Run(runS.Name, func(t *testing.T) { t.Parallel() - mtr, err := runMonitorOnce(t, cfgMap, runS.Location, stateLoader) - mtr.Wait() - callback(t, mtr, err) - mtr.Close() + + numberRuns := runS.NumberOfRuns + if numberRuns < 1 { + numberRuns = 1 // default to one run + } + + var events []*beat.Event + + var err error + var sf stdfields.StdMonitorFields + var conf mapstr.M + for i := 0; i < numberRuns; i++ { + var mtr *MonitorTestRun + mtr, err = runMonitorOnce(t, cfgMap, runS.Location, stateLoader) + mtr.wait() + events = append(events, mtr.Events()...) + sf = mtr.StdFields + conf = mtr.Config + mtr.close() + } + + sumMtr := MonitorTestRun{ + StdFields: sf, + Config: conf, + Events: func() []*beat.Event { + return events + }, + } + + callback(t, &sumMtr, err) }) } @@ -149,10 +186,10 @@ func (sdb *ScenarioDB) RunTagWithATwist(t *testing.T, tagName string, twist Twis type MonitorTestRun struct { StdFields stdfields.StdMonitorFields Config mapstr.M - Monitor *monitors.Monitor Events func() []*beat.Event - Wait func() - Close func() + monitor *monitors.Monitor + wait func() + close func() } func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.LocationWithID, stateLoader monitorstate.StateLoader) (mtr *MonitorTestRun, err error) { @@ -172,20 +209,20 @@ func runMonitorOnce(t *testing.T, monitorConfig mapstr.M, location *hbconfig.Loc mIface, err := f.Create(pipe, conf) require.NoError(t, err) - mtr.Monitor = mIface.(*monitors.Monitor) - require.NotNil(t, mtr.Monitor, "could not convert to monitor %v", mIface) + mtr.monitor = mIface.(*monitors.Monitor) + require.NotNil(t, mtr.monitor, "could not convert to monitor %v", mIface) mtr.Events = pipe.PublishedEvents // start the monitor - mtr.Monitor.Start() - mtr.Wait = func() { + mtr.monitor.Start() + mtr.wait = func() { // wait for the monitor to stop sched.WaitForRunOnce() // stop the monitor itself - mtr.Monitor.Stop() + mtr.monitor.Stop() closeFactory() } - mtr.Close = closeFactory + mtr.close = closeFactory return mtr, err } diff --git a/x-pack/heartbeat/scenarios/twists.go b/x-pack/heartbeat/scenarios/twists.go index 3b53176c3833..d9e38b063386 100644 --- a/x-pack/heartbeat/scenarios/twists.go +++ b/x-pack/heartbeat/scenarios/twists.go @@ -5,6 +5,8 @@ package scenarios import ( + "fmt" + "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/libbeat/processors/util" ) @@ -19,7 +21,19 @@ var TestLocationMpls = &config.LocationWithID{ }, } +var TwistEnableES = MakeTwist("with ES", func(s Scenario) Scenario { + s.ESEnabled = true + return s +}) + var TwistAddLocation = MakeTwist("add location", func(s Scenario) Scenario { s.Location = TestLocationDefault return s }) + +func TwistMultiRun(times int) Twist { + return MakeTwist(fmt.Sprintf("run %d times", times), func(s Scenario) Scenario { + s.NumberOfRuns = times + return s + }) +} From 3e285df34078fa9b4d3b51fdbfb677adfad1c662 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 17:24:01 -0500 Subject: [PATCH 085/102] Fix stateloader scenario tests --- heartbeat/monitors/factory.go | 1 + .../scenarios/es_integration_test.go | 53 ----------------- x-pack/heartbeat/scenarios/fakeloader.go | 59 +++++++++++++++++++ x-pack/heartbeat/scenarios/framework.go | 46 ++++++++++++--- .../heartbeat/scenarios/stateloader_test.go | 28 +++++++++ x-pack/heartbeat/scenarios/twists.go | 5 -- 6 files changed, 127 insertions(+), 65 deletions(-) delete mode 100644 x-pack/heartbeat/scenarios/es_integration_test.go create mode 100644 x-pack/heartbeat/scenarios/fakeloader.go create mode 100644 x-pack/heartbeat/scenarios/stateloader_test.go diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index 903d399be1e5..f91322618339 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -97,6 +97,7 @@ func NewFactory(fp FactoryParams) *RunnerFactory { logger: logp.L(), pipelineClientFactory: fp.PipelineClientFactory, beatLocation: fp.BeatLocation, + stateLoader: fp.StateLoader, } } diff --git a/x-pack/heartbeat/scenarios/es_integration_test.go b/x-pack/heartbeat/scenarios/es_integration_test.go deleted file mode 100644 index 4bda00296469..000000000000 --- a/x-pack/heartbeat/scenarios/es_integration_test.go +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one -// or more contributor license agreements. Licensed under the Elastic License; -// you may not use this file except in compliance with the Elastic License. - -package scenarios - -import ( - "testing" - - "github.com/stretchr/testify/require" - - "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" - "github.com/elastic/beats/v7/libbeat/beat" -) - -type stateEvent struct { - event *beat.Event - state *monitorstate.State -} - -func allStates(t *testing.T, events []*beat.Event) (stateEvents []stateEvent) { - for _, e := range events { - if stateIface, _ := e.Fields.GetValue("state"); stateIface != nil { - state, ok := stateIface.(*monitorstate.State) - require.True(t, ok, "state is not a monitorstate.State, got %v", state) - - se := stateEvent{event: e, state: state} - stateEvents = append(stateEvents, se) - } - } - return stateEvents -} - -func lastState(t *testing.T, events []*beat.Event) stateEvent { - all := allStates(t, events) - require.NotEmpty(t, all) - return all[len(all)-1] -} - -var esIntegTwists = MultiTwist(TwistAddLocation, TwistMultiRun(3), TwistEnableES) - -func TestStateContinuity(t *testing.T) { - Scenarios.RunAllWithATwist(t, esIntegTwists, func(t *testing.T, mtr *MonitorTestRun, err error) { - lastSS := lastState(t, mtr.Events()) - - require.Equal(t, monitorstate.StatusUp, lastSS.state.Status) - - allSS := allStates(t, mtr.Events()) - require.Len(t, allSS, 3) - - require.Equal(t, 3, lastSS.state.Checks) - }) -} diff --git a/x-pack/heartbeat/scenarios/fakeloader.go b/x-pack/heartbeat/scenarios/fakeloader.go new file mode 100644 index 000000000000..7d0dfa752422 --- /dev/null +++ b/x-pack/heartbeat/scenarios/fakeloader.go @@ -0,0 +1,59 @@ +// 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 scenarios + +import ( + "fmt" + "sync" + + "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" +) + +// Simulated state loader, close enough to test logic related to loading state from ES +// without actually using ES +type loaderDB struct { + keysToState map[string]*monitorstate.State + mtx *sync.Mutex +} + +func newLoaderDB() *loaderDB { + return &loaderDB{ + keysToState: map[string]*monitorstate.State{}, + mtx: &sync.Mutex{}, + } +} + +func loaderDbKey(sf stdfields.StdMonitorFields) string { + if sf.Location != nil { + return fmt.Sprintf("%s-%s", sf.ID, sf.Location.ID) + } + return sf.ID +} + +func (ldb loaderDB) AddState(sf stdfields.StdMonitorFields, state *monitorstate.State) { + ldb.mtx.Lock() + defer ldb.mtx.Unlock() + + ldb.keysToState[loaderDbKey(sf)] = state +} + +func (ldb loaderDB) GetState(sf stdfields.StdMonitorFields) *monitorstate.State { + ldb.mtx.Lock() + defer ldb.mtx.Unlock() + + found := ldb.keysToState[loaderDbKey(sf)] + return found +} + +func (ldb loaderDB) StateLoader() monitorstate.StateLoader { + return func(sf stdfields.StdMonitorFields) (*monitorstate.State, error) { + ldb.mtx.Lock() + defer ldb.mtx.Unlock() + + found := ldb.keysToState[loaderDbKey(sf)] + return found, nil + } +} diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework.go index 16238d25eb20..428b67b55686 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework.go @@ -38,7 +38,6 @@ type Scenario struct { Runner ScenarioRun Tags []string Location *hbconfig.LocationWithID - ESEnabled bool NumberOfRuns int } @@ -86,11 +85,6 @@ func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr return } - stateLoader := monitorstate.NilStateLoader - if s.ESEnabled { - stateLoader = monitorstate.IntegESLoader(t, "heartbeat-*,synthetics-*", TestLocationDefault) - } - t.Run(runS.Name, func(t *testing.T) { t.Parallel() @@ -99,6 +93,8 @@ func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr numberRuns = 1 // default to one run } + loaderDB := newLoaderDB() + var events []*beat.Event var err error @@ -106,9 +102,15 @@ func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr var conf mapstr.M for i := 0; i < numberRuns; i++ { var mtr *MonitorTestRun - mtr, err = runMonitorOnce(t, cfgMap, runS.Location, stateLoader) + mtr, err = runMonitorOnce(t, cfgMap, runS.Location, loaderDB.StateLoader()) + mtr.wait() events = append(events, mtr.Events()...) + + if lse := LastState(events).state; lse != nil { + loaderDB.AddState(mtr.StdFields, lse) + } + sf = mtr.StdFields conf = mtr.Config mtr.close() @@ -273,3 +275,33 @@ func setupFactoryAndSched(location *hbconfig.LocationWithID, stateLoader monitor sched, sched.Stop } + +type stateEvent struct { + event *beat.Event + state *monitorstate.State +} + +func AllStates(events []*beat.Event) (stateEvents []stateEvent) { + for _, e := range events { + if stateIface, _ := e.Fields.GetValue("state"); stateIface != nil { + state, ok := stateIface.(*monitorstate.State) + if !ok { + panic(fmt.Sprintf("state is not a monitorstate.State, got %v", state)) + } + + se := stateEvent{event: e, state: state} + stateEvents = append(stateEvents, se) + } + } + return stateEvents +} + +func LastState(events []*beat.Event) *stateEvent { + all := AllStates(events) + + if len(all) == 0 { + return nil + } + + return &all[len(all)-1] +} diff --git a/x-pack/heartbeat/scenarios/stateloader_test.go b/x-pack/heartbeat/scenarios/stateloader_test.go new file mode 100644 index 000000000000..952173ce3434 --- /dev/null +++ b/x-pack/heartbeat/scenarios/stateloader_test.go @@ -0,0 +1,28 @@ +// 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 scenarios + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" +) + +var esIntegTwists = MultiTwist(TwistAddLocation, TwistMultiRun(3)) + +func TestStateContinuity(t *testing.T) { + Scenarios.RunAllWithATwist(t, esIntegTwists, func(t *testing.T, mtr *MonitorTestRun, err error) { + lastSS := LastState(mtr.Events()) + + require.Equal(t, monitorstate.StatusUp, lastSS.state.Status) + + allSS := AllStates(mtr.Events()) + require.Len(t, allSS, 3) + + require.Equal(t, 3, lastSS.state.Checks) + }) +} diff --git a/x-pack/heartbeat/scenarios/twists.go b/x-pack/heartbeat/scenarios/twists.go index d9e38b063386..a433f287f761 100644 --- a/x-pack/heartbeat/scenarios/twists.go +++ b/x-pack/heartbeat/scenarios/twists.go @@ -21,11 +21,6 @@ var TestLocationMpls = &config.LocationWithID{ }, } -var TwistEnableES = MakeTwist("with ES", func(s Scenario) Scenario { - s.ESEnabled = true - return s -}) - var TwistAddLocation = MakeTwist("add location", func(s Scenario) Scenario { s.Location = TestLocationDefault return s From 3eede873cc51ad0a082a741fbebae7be103f66a1 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 17:30:41 -0500 Subject: [PATCH 086/102] Cleanup framework --- x-pack/heartbeat/scenarios/basics_test.go | 7 ++++--- .../scenarios/{ => framework}/fakeloader.go | 2 +- .../scenarios/{ => framework}/framework.go | 19 ++++++++++++++----- .../{ => framework}/framework_test.go | 2 +- x-pack/heartbeat/scenarios/scenarios.go | 18 +++++++----------- .../heartbeat/scenarios/stateloader_test.go | 13 +++++++------ x-pack/heartbeat/scenarios/twists.go | 7 ++++--- 7 files changed, 38 insertions(+), 30 deletions(-) rename x-pack/heartbeat/scenarios/{ => framework}/fakeloader.go (98%) rename x-pack/heartbeat/scenarios/{ => framework}/framework.go (95%) rename x-pack/heartbeat/scenarios/{ => framework}/framework_test.go (98%) diff --git a/x-pack/heartbeat/scenarios/basics_test.go b/x-pack/heartbeat/scenarios/basics_test.go index 475a86ec7e75..fa9f686f91fc 100644 --- a/x-pack/heartbeat/scenarios/basics_test.go +++ b/x-pack/heartbeat/scenarios/basics_test.go @@ -18,10 +18,11 @@ import ( _ "github.com/elastic/beats/v7/heartbeat/monitors/active/icmp" _ "github.com/elastic/beats/v7/heartbeat/monitors/active/tcp" _ "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser" + "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) func TestSimpleScenariosBasicFields(t *testing.T) { - Scenarios.RunAll(t, func(t *testing.T, mtr *MonitorTestRun, err error) { + scenarioDB.RunAll(t, func(t *testing.T, mtr *framework.MonitorTestRun, err error) { require.GreaterOrEqual(t, len(mtr.Events()), 1) lastCg := "" for i, e := range mtr.Events() { @@ -48,7 +49,7 @@ func TestSimpleScenariosBasicFields(t *testing.T) { } func TestLightweightUrls(t *testing.T) { - Scenarios.RunTag(t, "lightweight", func(t *testing.T, mtr *MonitorTestRun, err error) { + scenarioDB.RunTag(t, "lightweight", func(t *testing.T, mtr *framework.MonitorTestRun, err error) { for _, e := range mtr.Events() { testslike.Test(t, lookslike.MustCompile(map[string]interface{}{ "url": map[string]interface{}{ @@ -62,7 +63,7 @@ func TestLightweightUrls(t *testing.T) { } func TestLightweightSummaries(t *testing.T) { - Scenarios.RunTag(t, "lightweight", func(t *testing.T, mtr *MonitorTestRun, err error) { + scenarioDB.RunTag(t, "lightweight", func(t *testing.T, mtr *framework.MonitorTestRun, err error) { all := mtr.Events() lastEvent, firstEvents := all[len(all)-1], all[:len(all)-1] testslike.Test(t, lookslike.MustCompile(map[string]interface{}{ diff --git a/x-pack/heartbeat/scenarios/fakeloader.go b/x-pack/heartbeat/scenarios/framework/fakeloader.go similarity index 98% rename from x-pack/heartbeat/scenarios/fakeloader.go rename to x-pack/heartbeat/scenarios/framework/fakeloader.go index 7d0dfa752422..d4637328353b 100644 --- a/x-pack/heartbeat/scenarios/fakeloader.go +++ b/x-pack/heartbeat/scenarios/framework/fakeloader.go @@ -2,7 +2,7 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. -package scenarios +package framework import ( "fmt" diff --git a/x-pack/heartbeat/scenarios/framework.go b/x-pack/heartbeat/scenarios/framework/framework.go similarity index 95% rename from x-pack/heartbeat/scenarios/framework.go rename to x-pack/heartbeat/scenarios/framework/framework.go index 428b67b55686..877b47762176 100644 --- a/x-pack/heartbeat/scenarios/framework.go +++ b/x-pack/heartbeat/scenarios/framework/framework.go @@ -2,7 +2,7 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. -package scenarios +package framework import ( "fmt" @@ -107,7 +107,7 @@ func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr mtr.wait() events = append(events, mtr.Events()...) - if lse := LastState(events).state; lse != nil { + if lse := LastState(events).State; lse != nil { loaderDB.AddState(mtr.StdFields, lse) } @@ -134,6 +134,15 @@ type ScenarioDB struct { initOnce *sync.Once } +func NewScenarioDB() *ScenarioDB { + return &ScenarioDB{ + initOnce: &sync.Once{}, + ByTag: map[string][]Scenario{}, + All: []Scenario{}, + } + +} + func (sdb *ScenarioDB) Init() { var prunedList []Scenario browserCapable := os.Getenv("ELASTIC_SYNTHETICS_CAPABLE") == "true" @@ -277,8 +286,8 @@ func setupFactoryAndSched(location *hbconfig.LocationWithID, stateLoader monitor } type stateEvent struct { - event *beat.Event - state *monitorstate.State + Event *beat.Event + State *monitorstate.State } func AllStates(events []*beat.Event) (stateEvents []stateEvent) { @@ -289,7 +298,7 @@ func AllStates(events []*beat.Event) (stateEvents []stateEvent) { panic(fmt.Sprintf("state is not a monitorstate.State, got %v", state)) } - se := stateEvent{event: e, state: state} + se := stateEvent{Event: e, State: state} stateEvents = append(stateEvents, se) } } diff --git a/x-pack/heartbeat/scenarios/framework_test.go b/x-pack/heartbeat/scenarios/framework/framework_test.go similarity index 98% rename from x-pack/heartbeat/scenarios/framework_test.go rename to x-pack/heartbeat/scenarios/framework/framework_test.go index 2df107a8a99f..fc5e3e632a6f 100644 --- a/x-pack/heartbeat/scenarios/framework_test.go +++ b/x-pack/heartbeat/scenarios/framework/framework_test.go @@ -2,7 +2,7 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. -package scenarios +package framework import ( "testing" diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index 1e37f75c95f8..8e059faf1db5 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -19,14 +19,10 @@ import ( "github.com/elastic/elastic-agent-libs/mapstr" "github.com/elastic/beats/v7/heartbeat/hbtest" + "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) -var Scenarios = &ScenarioDB{ - initOnce: &sync.Once{}, - ByTag: map[string][]Scenario{}, - All: []Scenario{}, -} - +var scenarioDB = framework.NewScenarioDB() var testWs *httptest.Server var testWsOnce = &sync.Once{} @@ -54,8 +50,8 @@ func startTestWebserver(t *testing.T) *httptest.Server { } func init() { - Scenarios.Add( - Scenario{ + scenarioDB.Add( + framework.Scenario{ Name: "http-simple", Type: "http", Tags: []string{"lightweight", "http"}, @@ -71,7 +67,7 @@ func init() { return config, nil, nil }, }, - Scenario{ + framework.Scenario{ Name: "tcp-simple", Type: "tcp", Tags: []string{"lightweight", "tcp"}, @@ -91,7 +87,7 @@ func init() { return config, nil, nil }, }, - Scenario{ + framework.Scenario{ Name: "simple-icmp", Type: "icmp", Tags: []string{"icmp"}, @@ -105,7 +101,7 @@ func init() { }, func() {}, nil }, }, - Scenario{ + framework.Scenario{ Name: "simple-browser", Type: "browser", Tags: []string{"browser", "browser-inline"}, diff --git a/x-pack/heartbeat/scenarios/stateloader_test.go b/x-pack/heartbeat/scenarios/stateloader_test.go index 952173ce3434..fd5a9055d351 100644 --- a/x-pack/heartbeat/scenarios/stateloader_test.go +++ b/x-pack/heartbeat/scenarios/stateloader_test.go @@ -10,19 +10,20 @@ import ( "github.com/stretchr/testify/require" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" + "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) -var esIntegTwists = MultiTwist(TwistAddLocation, TwistMultiRun(3)) +var esIntegTwists = framework.MultiTwist(TwistAddLocation, TwistMultiRun(3)) func TestStateContinuity(t *testing.T) { - Scenarios.RunAllWithATwist(t, esIntegTwists, func(t *testing.T, mtr *MonitorTestRun, err error) { - lastSS := LastState(mtr.Events()) + scenarioDB.RunAllWithATwist(t, esIntegTwists, func(t *testing.T, mtr *framework.MonitorTestRun, err error) { + lastSS := framework.LastState(mtr.Events()) - require.Equal(t, monitorstate.StatusUp, lastSS.state.Status) + require.Equal(t, monitorstate.StatusUp, lastSS.State.Status) - allSS := AllStates(mtr.Events()) + allSS := framework.AllStates(mtr.Events()) require.Len(t, allSS, 3) - require.Equal(t, 3, lastSS.state.Checks) + require.Equal(t, 3, lastSS.State.Checks) }) } diff --git a/x-pack/heartbeat/scenarios/twists.go b/x-pack/heartbeat/scenarios/twists.go index a433f287f761..8d7c0188f377 100644 --- a/x-pack/heartbeat/scenarios/twists.go +++ b/x-pack/heartbeat/scenarios/twists.go @@ -9,6 +9,7 @@ import ( "github.com/elastic/beats/v7/heartbeat/config" "github.com/elastic/beats/v7/libbeat/processors/util" + "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) var TestLocationDefault = TestLocationMpls @@ -21,13 +22,13 @@ var TestLocationMpls = &config.LocationWithID{ }, } -var TwistAddLocation = MakeTwist("add location", func(s Scenario) Scenario { +var TwistAddLocation = framework.MakeTwist("add location", func(s framework.Scenario) framework.Scenario { s.Location = TestLocationDefault return s }) -func TwistMultiRun(times int) Twist { - return MakeTwist(fmt.Sprintf("run %d times", times), func(s Scenario) Scenario { +func TwistMultiRun(times int) framework.Twist { + return framework.MakeTwist(fmt.Sprintf("run %d times", times), func(s framework.Scenario) framework.Scenario { s.NumberOfRuns = times return s }) From 8ff8267e6507342e2376d244950fda6657b1c235 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 17:47:39 -0500 Subject: [PATCH 087/102] Make linter happy --- x-pack/heartbeat/scenarios/scenarios.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index 8e059faf1db5..cdfe23276cc6 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -35,9 +35,13 @@ func startTestWebserver(t *testing.T) *httptest.Server { for i := 0; i < 20; i++ { var resp *http.Response resp, err = http.Get(testWs.URL) - if err == nil && resp.StatusCode == 200 { - break + if err == nil { + resp.Body.Close() + if resp.StatusCode == 200 { + break + } } + time.Sleep(time.Millisecond * 250) } From fdc4507af6420e60c8ccf6e440cef4d5cae30581 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 30 Aug 2022 17:58:31 -0500 Subject: [PATCH 088/102] Make linter happy --- x-pack/heartbeat/scenarios/scenarios.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index cdfe23276cc6..d270f7c58385 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -5,6 +5,7 @@ package scenarios import ( + "context" "fmt" "net/http" "net/http/httptest" @@ -34,7 +35,8 @@ func startTestWebserver(t *testing.T) *httptest.Server { var err error for i := 0; i < 20; i++ { var resp *http.Response - resp, err = http.Get(testWs.URL) + req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, testWs.URL, nil) + resp, err = http.DefaultClient.Do(req) if err == nil { resp.Body.Close() if resp.StatusCode == 200 { From 27435f0833f54bb191feaecb2840a461f467046d Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 31 Aug 2022 12:48:51 -0500 Subject: [PATCH 089/102] Fix windows targetting --- .../heartbeat/scenarios/browserscenarios.go | 48 +++++++++++++++++++ x-pack/heartbeat/scenarios/scenarios.go | 28 +---------- 2 files changed, 50 insertions(+), 26 deletions(-) create mode 100644 x-pack/heartbeat/scenarios/browserscenarios.go diff --git a/x-pack/heartbeat/scenarios/browserscenarios.go b/x-pack/heartbeat/scenarios/browserscenarios.go new file mode 100644 index 000000000000..9cece3db988c --- /dev/null +++ b/x-pack/heartbeat/scenarios/browserscenarios.go @@ -0,0 +1,48 @@ +// 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. + +//go:build linux || darwin +// +build linux darwin + +package scenarios + +import ( + "fmt" + "os" + "testing" + + _ "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser" + "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" + "github.com/elastic/elastic-agent-libs/mapstr" +) + +func init() { + scenarioDB.Add( + framework.Scenario{ + Name: "simple-browser", + Type: "browser", + Tags: []string{"browser", "browser-inline"}, + Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { + err = os.Setenv("ELASTIC_SYNTHETICS_CAPABLE", "true") + if err != nil { + return nil, nil, err + } + server := startTestWebserver(t) + config = mapstr.M{ + "id": "browser-test-id", + "name": "browser-test-name", + "type": "browser", + "schedule": "@every 1m", + "hosts": []string{"127.0.0.1"}, + "source": mapstr.M{ + "inline": mapstr.M{ + "script": fmt.Sprintf("step('load server', async () => {await page.goto('%s')})", server.URL), + }, + }, + } + return config, nil, nil + }, + }, + ) +} diff --git a/x-pack/heartbeat/scenarios/scenarios.go b/x-pack/heartbeat/scenarios/scenarios.go index d270f7c58385..e67f5054805c 100644 --- a/x-pack/heartbeat/scenarios/scenarios.go +++ b/x-pack/heartbeat/scenarios/scenarios.go @@ -10,7 +10,6 @@ import ( "net/http" "net/http/httptest" "net/url" - "os" "sync" "testing" "time" @@ -55,6 +54,8 @@ func startTestWebserver(t *testing.T) *httptest.Server { return testWs } +// Note, no browser scenarios here, those all go in browserscenarios.go +// since they have different build tags func init() { scenarioDB.Add( framework.Scenario{ @@ -107,30 +108,5 @@ func init() { }, func() {}, nil }, }, - framework.Scenario{ - Name: "simple-browser", - Type: "browser", - Tags: []string{"browser", "browser-inline"}, - Runner: func(t *testing.T) (config mapstr.M, close func(), err error) { - err = os.Setenv("ELASTIC_SYNTHETICS_CAPABLE", "true") - if err != nil { - return nil, nil, err - } - server := startTestWebserver(t) - config = mapstr.M{ - "id": "browser-test-id", - "name": "browser-test-name", - "type": "browser", - "schedule": "@every 1m", - "hosts": []string{"127.0.0.1"}, - "source": mapstr.M{ - "inline": mapstr.M{ - "script": fmt.Sprintf("step('load server', async () => {await page.goto('%s')})", server.URL), - }, - }, - } - return config, nil, nil - }, - }, ) } From 3739f240e402a04bd650c385f0f75327ac0a698b Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 31 Aug 2022 15:10:44 -0500 Subject: [PATCH 090/102] Restrict all browser source from win builds --- x-pack/heartbeat/monitors/browser/source/inline.go | 2 ++ x-pack/heartbeat/monitors/browser/source/inline_test.go | 2 ++ x-pack/heartbeat/monitors/browser/source/local.go | 3 +++ x-pack/heartbeat/monitors/browser/source/local_test.go | 3 +++ x-pack/heartbeat/monitors/browser/source/offline.go | 2 ++ x-pack/heartbeat/monitors/browser/source/project.go | 2 ++ x-pack/heartbeat/monitors/browser/source/project_test.go | 2 ++ x-pack/heartbeat/monitors/browser/source/source.go | 1 + x-pack/heartbeat/monitors/browser/source/validatepackage.go | 3 +++ .../heartbeat/monitors/browser/source/validatepackage_test.go | 3 +++ x-pack/heartbeat/monitors/browser/source/zipurl.go | 3 +++ x-pack/heartbeat/monitors/browser/source/zipurl_test.go | 4 +++- 12 files changed, 29 insertions(+), 1 deletion(-) diff --git a/x-pack/heartbeat/monitors/browser/source/inline.go b/x-pack/heartbeat/monitors/browser/source/inline.go index 890d1902e0d3..27fb84bfdacd 100644 --- a/x-pack/heartbeat/monitors/browser/source/inline.go +++ b/x-pack/heartbeat/monitors/browser/source/inline.go @@ -1,6 +1,8 @@ // 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. +//go:build linux || darwin +// +build linux darwin package source diff --git a/x-pack/heartbeat/monitors/browser/source/inline_test.go b/x-pack/heartbeat/monitors/browser/source/inline_test.go index d97dbd8a1205..24f9a6efa945 100644 --- a/x-pack/heartbeat/monitors/browser/source/inline_test.go +++ b/x-pack/heartbeat/monitors/browser/source/inline_test.go @@ -1,6 +1,8 @@ // 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. +//go:build linux || darwin +// +build linux darwin package source diff --git a/x-pack/heartbeat/monitors/browser/source/local.go b/x-pack/heartbeat/monitors/browser/source/local.go index ebaf628214d6..44104ac60e99 100644 --- a/x-pack/heartbeat/monitors/browser/source/local.go +++ b/x-pack/heartbeat/monitors/browser/source/local.go @@ -2,6 +2,9 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. +//go:build linux || darwin +// +build linux darwin + package source import ( diff --git a/x-pack/heartbeat/monitors/browser/source/local_test.go b/x-pack/heartbeat/monitors/browser/source/local_test.go index 40a9b9b1affc..c391b49719d9 100644 --- a/x-pack/heartbeat/monitors/browser/source/local_test.go +++ b/x-pack/heartbeat/monitors/browser/source/local_test.go @@ -2,6 +2,9 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. +//go:build linux || darwin +// +build linux darwin + package source import ( diff --git a/x-pack/heartbeat/monitors/browser/source/offline.go b/x-pack/heartbeat/monitors/browser/source/offline.go index 0347958a8120..a16ed88ff52d 100644 --- a/x-pack/heartbeat/monitors/browser/source/offline.go +++ b/x-pack/heartbeat/monitors/browser/source/offline.go @@ -1,6 +1,8 @@ // 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. +//go:build linux || darwin +// +build linux darwin package source diff --git a/x-pack/heartbeat/monitors/browser/source/project.go b/x-pack/heartbeat/monitors/browser/source/project.go index effea44eb8a6..421b54f2d7c7 100644 --- a/x-pack/heartbeat/monitors/browser/source/project.go +++ b/x-pack/heartbeat/monitors/browser/source/project.go @@ -1,6 +1,8 @@ // 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. +//go:build linux || darwin +// +build linux darwin package source diff --git a/x-pack/heartbeat/monitors/browser/source/project_test.go b/x-pack/heartbeat/monitors/browser/source/project_test.go index b3aa25eedbf6..e9a3caec246e 100644 --- a/x-pack/heartbeat/monitors/browser/source/project_test.go +++ b/x-pack/heartbeat/monitors/browser/source/project_test.go @@ -1,6 +1,8 @@ // 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. +//go:build linux || darwin +// +build linux darwin package source diff --git a/x-pack/heartbeat/monitors/browser/source/source.go b/x-pack/heartbeat/monitors/browser/source/source.go index b597a0458855..1c0af2eb3213 100644 --- a/x-pack/heartbeat/monitors/browser/source/source.go +++ b/x-pack/heartbeat/monitors/browser/source/source.go @@ -1,6 +1,7 @@ // 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. + //go:build linux || darwin // +build linux darwin diff --git a/x-pack/heartbeat/monitors/browser/source/validatepackage.go b/x-pack/heartbeat/monitors/browser/source/validatepackage.go index c67404232128..7492580f8cdc 100644 --- a/x-pack/heartbeat/monitors/browser/source/validatepackage.go +++ b/x-pack/heartbeat/monitors/browser/source/validatepackage.go @@ -2,6 +2,9 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. +//go:build linux || darwin +// +build linux darwin + package source import ( diff --git a/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go b/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go index 014e1fd2fa98..ab2b298efcca 100644 --- a/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go +++ b/x-pack/heartbeat/monitors/browser/source/validatepackage_test.go @@ -2,6 +2,9 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. +//go:build linux || darwin +// +build linux darwin + package source import ( diff --git a/x-pack/heartbeat/monitors/browser/source/zipurl.go b/x-pack/heartbeat/monitors/browser/source/zipurl.go index ebd5a1c547fc..553cbe6662f3 100644 --- a/x-pack/heartbeat/monitors/browser/source/zipurl.go +++ b/x-pack/heartbeat/monitors/browser/source/zipurl.go @@ -2,6 +2,9 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. +//go:build linux || darwin +// +build linux darwin + package source import ( diff --git a/x-pack/heartbeat/monitors/browser/source/zipurl_test.go b/x-pack/heartbeat/monitors/browser/source/zipurl_test.go index 7078436f14a8..8bf196e21c20 100644 --- a/x-pack/heartbeat/monitors/browser/source/zipurl_test.go +++ b/x-pack/heartbeat/monitors/browser/source/zipurl_test.go @@ -1,7 +1,9 @@ // 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. -// + +//go:build linux || darwin +// +build linux darwin package source From e9386a442f47b2c556feaecc592ab4eb7db49c31 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 31 Aug 2022 15:12:08 -0500 Subject: [PATCH 091/102] Fix win deps --- x-pack/heartbeat/scenarios/basics_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/x-pack/heartbeat/scenarios/basics_test.go b/x-pack/heartbeat/scenarios/basics_test.go index fa9f686f91fc..7bb66a696ea3 100644 --- a/x-pack/heartbeat/scenarios/basics_test.go +++ b/x-pack/heartbeat/scenarios/basics_test.go @@ -17,7 +17,6 @@ import ( _ "github.com/elastic/beats/v7/heartbeat/monitors/active/http" _ "github.com/elastic/beats/v7/heartbeat/monitors/active/icmp" _ "github.com/elastic/beats/v7/heartbeat/monitors/active/tcp" - _ "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser" "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) From 793eb39280cc9b0fce6ce83c034f654617c9d3ea Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 6 Sep 2022 20:35:16 -0500 Subject: [PATCH 092/102] Incorporate PR feedback --- heartbeat/monitors/factory.go | 2 ++ heartbeat/monitors/wrappers/monitorstate/monitorstate.go | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index f91322618339..f1e4593b7ee0 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -197,6 +197,8 @@ func newCommonPublishConfigs(info beat.Info, beatLocation *config.LocationWithID // Early stage processors for setting data_stream, event.dataset, and index to write to // Use the monitor-specific location if possible, otherwise use the beat's location + // Generally speaking direct HB users would use the beat location, and the synthetics service may as well (TBD) + // while Fleet configured monitors will always use a per location monitor var loc *config.LocationWithID if sf.Location != nil { loc = sf.Location diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index ca7371693a17..14df0a52c6da 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -87,7 +87,7 @@ func (s *State) incrementCounters(status StateStatus) { // truncate flap history to be at most as many items as the threshold indicates, minus one func (s *State) truncateFlapHistory() { endIdx := len(s.FlapHistory) - if endIdx < 0 { + if endIdx <= 0 { return // flap history is empty } // truncate to one less than the threshold since our later calculations From b9f75909b276435d7f326f71e18cdc5acc2f49fd Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 6 Sep 2022 20:39:31 -0500 Subject: [PATCH 093/102] Apply suggestions from code review Co-authored-by: Vignesh Shanmugam --- heartbeat/hbtestllext/isdefs.go | 6 +++--- heartbeat/monitors/factory.go | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/heartbeat/hbtestllext/isdefs.go b/heartbeat/hbtestllext/isdefs.go index 7e5de4f11b1f..f5fdc4feeb87 100644 --- a/heartbeat/hbtestllext/isdefs.go +++ b/heartbeat/hbtestllext/isdefs.go @@ -74,11 +74,11 @@ var IsECSErr = func(expectedErr *ecserr.ECSErr) isdef.IsDef { givenErr = &givenErrNoPtr if expectedErr.Code != givenErr.Code { - return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", expectedErr.Code, givenErr.Code) + return llresult.SimpleResult(path, false, "ECS error code does not match, expected %s, got %s", expectedErr.Code, givenErr.Code) } if expectedErr.Type != givenErr.Type { - return llresult.SimpleResult(path, false, "ECS error message does not match, expected %s, got %s", expectedErr.Type, givenErr.Type) + return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", expectedErr.Type, givenErr.Type) } if expectedErr.Message != givenErr.Message { @@ -101,7 +101,7 @@ var IsECSErrMatchingCode = func(ecode ecserr.ECode, messageContains string) isde givenErr = &givenErrNoPtr if ecode != givenErr.Code { - return llresult.SimpleResult(path, false, "ECS error type does not match, expected %s, got %s", ecode, givenErr.Code) + return llresult.SimpleResult(path, false, "ECS error code does not match, expected %s, got %s", ecode, givenErr.Code) } if !strings.Contains(givenErr.Message, messageContains) { diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index f91322618339..2815dd455f49 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -265,7 +265,7 @@ func preProcessors(info beat.Info, location *config.LocationWithID, settings pub geoM, err := util.GeoConfigToMap(location.Geo) if err != nil { geoErrOnce.Do(func() { - logp.L().Warnf("could not add heartbeat geo info: %s", err) + logp.L().Warnf("could not add heartbeat geo info: %w", err) }) } From 70bd4441e606e9e10563e8a4f0b508c14e5432bb Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 7 Sep 2022 13:17:37 -0500 Subject: [PATCH 094/102] Update heartbeat/monitors/wrappers/monitorstate/tracker.go Co-authored-by: Vignesh Shanmugam --- heartbeat/monitors/wrappers/monitorstate/tracker.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/tracker.go b/heartbeat/monitors/wrappers/monitorstate/tracker.go index 53ebb708b714..6bd8069a27a6 100644 --- a/heartbeat/monitors/wrappers/monitorstate/tracker.go +++ b/heartbeat/monitors/wrappers/monitorstate/tracker.go @@ -88,7 +88,7 @@ func (t *Tracker) getCurrentState(sf stdfields.StdMonitorFields) (state *State) } } if err != nil { - logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor %s", tries, sf.ID) + logp.L().Warn("could not load prior state from elasticsearch after %d attempts, will create new state for monitor: %s", tries, sf.ID) } if loadedState != nil { From c11982f8824068f9af8377e33b4c71cb14f2c9ac Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 7 Sep 2022 16:40:26 -0500 Subject: [PATCH 095/102] Incorporate PR feedback --- heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go index d8e616e2af25..3a84390212ca 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate_test.go @@ -53,7 +53,7 @@ func TestDuration(t *testing.T) { time.Sleep(time.Millisecond * 10) ms.recordCheck(TestSf, StatusUp) // Pretty forgiving upper bound to account for flaky CI - require.True(t, ms.DurationMs > 9 && ms.DurationMs < 300, "Expected duration to be ~10ms, got %d", ms.DurationMs) + require.True(t, ms.DurationMs > 9 && ms.DurationMs < 900, "Expected duration to be ~10ms, got %d", ms.DurationMs) } // recordFlappingSeries is a helper that should always put the monitor into a flapping state. From ee08dc791af97de83c526deaf6395cd8367b04de Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 7 Sep 2022 19:31:55 -0500 Subject: [PATCH 096/102] Remove unnecessary state loader assignment --- x-pack/heartbeat/scenarios/framework/framework.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/x-pack/heartbeat/scenarios/framework/framework.go b/x-pack/heartbeat/scenarios/framework/framework.go index 877b47762176..b538ae70d70c 100644 --- a/x-pack/heartbeat/scenarios/framework/framework.go +++ b/x-pack/heartbeat/scenarios/framework/framework.go @@ -266,10 +266,6 @@ func setupFactoryAndSched(location *hbconfig.LocationWithID, stateLoader monitor true, ) - if stateLoader == nil { - stateLoader = monitorstate.NilStateLoader - } - return monitors.NewFactory(monitors.FactoryParams{ BeatInfo: info, AddTask: sched.Add, From eed6a8978cafb4479b6a5d7a10157e222b4d9e2d Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Wed, 7 Sep 2022 19:40:12 -0500 Subject: [PATCH 097/102] Remove browser from win tests --- x-pack/heartbeat/scenarios/basics_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/x-pack/heartbeat/scenarios/basics_test.go b/x-pack/heartbeat/scenarios/basics_test.go index fa9f686f91fc..7bb66a696ea3 100644 --- a/x-pack/heartbeat/scenarios/basics_test.go +++ b/x-pack/heartbeat/scenarios/basics_test.go @@ -17,7 +17,6 @@ import ( _ "github.com/elastic/beats/v7/heartbeat/monitors/active/http" _ "github.com/elastic/beats/v7/heartbeat/monitors/active/icmp" _ "github.com/elastic/beats/v7/heartbeat/monitors/active/tcp" - _ "github.com/elastic/beats/v7/x-pack/heartbeat/monitors/browser" "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) From 6ecac3e4d49b641f6f25a27de116afd5db317a68 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Thu, 8 Sep 2022 22:23:00 -0500 Subject: [PATCH 098/102] Fix state loader to only use ES state loader with ES output --- heartbeat/beater/heartbeat.go | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 9433c9d9ccae..013083dcf9c0 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -67,16 +67,17 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { return nil, fmt.Errorf("error reading config file: %w", err) } - // Connect to ES and setup the State loader - esc, err := getESClient(b.Config.Output.Config()) - if err != nil { - return nil, err - } - var stateLoader monitorstate.StateLoader - if esc != nil { - stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*", parsedConfig.Location) - } else { - stateLoader = monitorstate.NilStateLoader + stateLoader := monitorstate.NilStateLoader + + if b.Config.Output.Name() == "elasticsearch" { + // Connect to ES and setup the State loader + esc, err := getESClient(b.Config.Output.Config()) + if err != nil { + return nil, err + } + if esc != nil { + stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*", parsedConfig.Location) + } } limit := parsedConfig.Scheduler.Limit From bc39d5af84c5f5612239fafa99d28e3dea9476b4 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Fri, 9 Sep 2022 16:29:54 -0500 Subject: [PATCH 099/102] Don't run integ tests on windows --- heartbeat/magefile.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/heartbeat/magefile.go b/heartbeat/magefile.go index 98a8c9f8b13b..1db980b0f1a6 100644 --- a/heartbeat/magefile.go +++ b/heartbeat/magefile.go @@ -23,6 +23,7 @@ package main import ( "context" "fmt" + "runtime" "time" "github.com/magefile/mage/mg" @@ -91,7 +92,10 @@ func IntegTest() { } func GoIntegTest(ctx context.Context) error { - return devtools.GoIntegTestFromHost(ctx, devtools.DefaultGoTestIntegrationFromHostArgs()) + if runtime.GOOS != "windows" { + return devtools.GoIntegTestFromHost(ctx, devtools.DefaultGoTestIntegrationFromHostArgs()) + } + return nil } func PythonIntegTest() { From 045969bf266a86b3b3cb44682ba7c88063edcd4a Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 12 Sep 2022 10:57:48 -0500 Subject: [PATCH 100/102] Revert "ci: enable windows for testing heartbeat (#32937)" This reverts commit 8552e34a6ad31c9f7ed3bf2a1202a00c401cfa43. --- x-pack/heartbeat/Jenkinsfile.yml | 58 +++++++++++++++----------------- 1 file changed, 28 insertions(+), 30 deletions(-) diff --git a/x-pack/heartbeat/Jenkinsfile.yml b/x-pack/heartbeat/Jenkinsfile.yml index b2c2035734ce..1bd04921e050 100644 --- a/x-pack/heartbeat/Jenkinsfile.yml +++ b/x-pack/heartbeat/Jenkinsfile.yml @@ -34,36 +34,34 @@ stages: - "macosTest" tags: true ## for all the tags stage: extended - windows-2022: - mage: "mage build test" - platforms: ## override default labels in this specific stage. - - "windows-2022" - stage: mandatory - windows-2019: - mage: "mage build test" - platforms: ## override default labels in this specific stage. - - "windows-2019" - stage: extended_win - windows-2016: - mage: "mage build test" - platforms: ## override default labels in this specific stage. - - "windows-2016" - stage: mandatory - windows-2012: - mage: "mage build test" - platforms: ## override default labels in this specific stage. - - "windows-2012-r2" - stage: extended_win - windows-10: - mage: "mage build test" - platforms: ## override default labels in this specific stage. - - "windows-10" - stage: extended_win - windows-8: - mage: "mage build test" - platforms: ## override default labels in this specific stage. - - "windows-8" - stage: extended_win +# TODO: there are windows test failures already reported +# https://github.com/elastic/beats/issues/23957 and https://github.com/elastic/beats/issues/23958 +# waiting for being fixed. +# windows-2019: +# mage: "mage build test" +# platforms: ## override default labels in this specific stage. +# - "windows-2019" +# stage: extended_win +# windows-2016: +# mage: "mage build test" +# platforms: ## override default labels in this specific stage. +# - "windows-2016" +# stage: mandatory +# windows-2012: +# mage: "mage build test" +# platforms: ## override default labels in this specific stage. +# - "windows-2012-r2" +# stage: extended_win +# windows-10: +# mage: "mage build test" +# platforms: ## override default labels in this specific stage. +# - "windows-10" +# stage: extended_win +# windows-8: +# mage: "mage build test" +# platforms: ## override default labels in this specific stage. +# - "windows-8" +# stage: extended_win packaging-linux: packaging-linux: "mage package" e2e: From 779da1bc84bfc38effbef1469e278808fe54708a Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Mon, 12 Sep 2022 16:55:52 -0500 Subject: [PATCH 101/102] Rename monitor.location to monitor.run_from and add tests for observer metadata --- heartbeat/monitors/factory.go | 4 ++-- heartbeat/monitors/mocks.go | 17 +++++++++++------ heartbeat/monitors/stdfields/stdfields.go | 2 +- .../monitors/wrappers/monitorstate/esloader.go | 4 ++-- .../wrappers/monitorstate/monitorstate.go | 2 +- x-pack/heartbeat/scenarios/basics_test.go | 15 +++++++++++++++ .../heartbeat/scenarios/framework/fakeloader.go | 4 ++-- .../heartbeat/scenarios/framework/framework.go | 10 +++++----- .../scenarios/framework/framework_test.go | 10 +++++----- x-pack/heartbeat/scenarios/stateloader_test.go | 2 +- x-pack/heartbeat/scenarios/twists.go | 4 ++-- 11 files changed, 47 insertions(+), 27 deletions(-) diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index 94a3b0f3f93f..c293ac6922c5 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -200,8 +200,8 @@ func newCommonPublishConfigs(info beat.Info, beatLocation *config.LocationWithID // Generally speaking direct HB users would use the beat location, and the synthetics service may as well (TBD) // while Fleet configured monitors will always use a per location monitor var loc *config.LocationWithID - if sf.Location != nil { - loc = sf.Location + if sf.RunFrom != nil { + loc = sf.RunFrom } else { loc = beatLocation } diff --git a/heartbeat/monitors/mocks.go b/heartbeat/monitors/mocks.go index 17b077822eed..bc6695f3be9e 100644 --- a/heartbeat/monitors/mocks.go +++ b/heartbeat/monitors/mocks.go @@ -90,10 +90,11 @@ func makeMockFactory(pluginsReg *plugin.PluginsReg) (factory *RunnerFactory, sch } type mockClient struct { - publishLog []*beat.Event - pipeline beat.Pipeline - closed bool - mtx sync.Mutex + publishLog []*beat.Event + pipeline beat.Pipeline + closed bool + mtx sync.Mutex + clientConfig beat.ClientConfig } func (c *mockClient) IsClosed() bool { @@ -104,6 +105,10 @@ func (c *mockClient) IsClosed() bool { } func (c *mockClient) Publish(e beat.Event) { + if c.clientConfig.Processing.Processor != nil { + outE, _ := c.clientConfig.Processing.Processor.Run(&e) + e = *outE + } c.PublishAll([]beat.Event{e}) } @@ -148,11 +153,11 @@ func (pc *MockPipeline) Connect() (beat.Client, error) { return pc.ConnectWith(beat.ClientConfig{}) } -func (pc *MockPipeline) ConnectWith(beat.ClientConfig) (beat.Client, error) { +func (pc *MockPipeline) ConnectWith(cc beat.ClientConfig) (beat.Client, error) { pc.mtx.Lock() defer pc.mtx.Unlock() - c := &mockClient{pipeline: pc} + c := &mockClient{pipeline: pc, clientConfig: cc} pc.Clients = append(pc.Clients, c) diff --git a/heartbeat/monitors/stdfields/stdfields.go b/heartbeat/monitors/stdfields/stdfields.go index d709052a04d9..d0773a49e798 100644 --- a/heartbeat/monitors/stdfields/stdfields.go +++ b/heartbeat/monitors/stdfields/stdfields.go @@ -50,7 +50,7 @@ type StdMonitorFields struct { ZipUrl *config.C `config:"zip_url"` Local *config.C `config:"local"` } `config:"source"` - Location *hbconfig.LocationWithID `config:"location"` + RunFrom *hbconfig.LocationWithID `config:"run_from"` } func ConfigToStdMonitorFields(conf *config.C) (StdMonitorFields, error) { diff --git a/heartbeat/monitors/wrappers/monitorstate/esloader.go b/heartbeat/monitors/wrappers/monitorstate/esloader.go index f51242fa6d3b..3f4165193ea3 100644 --- a/heartbeat/monitors/wrappers/monitorstate/esloader.go +++ b/heartbeat/monitors/wrappers/monitorstate/esloader.go @@ -56,9 +56,9 @@ func MakeESLoader(esc *elasticsearch.Client, indexPattern string, beatLocation * }, } - if sf.Location != nil { + if sf.RunFrom != nil { queryMustClauses = append(queryMustClauses, mapstr.M{ - "match": mapstr.M{"observer.name": sf.Location.ID}, + "match": mapstr.M{"observer.name": sf.RunFrom.ID}, }) } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 14df0a52c6da..432cb4b97e82 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -44,7 +44,7 @@ func newMonitorState(sf stdfields.StdMonitorFields, status StateStatus, ctr int, // ID is unique and sortable by time for easier aggregations // Note that we add an incrementing counter to help with the fact that // millisecond res isn't quite enough for uniqueness (esp. in tests) - ID: fmt.Sprintf("%s-%s-%x-%x", sf.ID, sf.Location, now.UnixMilli(), ctr), + ID: fmt.Sprintf("%s-%s-%x-%x", sf.ID, sf.RunFrom, now.UnixMilli(), ctr), StartedAt: now, DurationMs: 0, Status: status, diff --git a/x-pack/heartbeat/scenarios/basics_test.go b/x-pack/heartbeat/scenarios/basics_test.go index 7bb66a696ea3..db82493da704 100644 --- a/x-pack/heartbeat/scenarios/basics_test.go +++ b/x-pack/heartbeat/scenarios/basics_test.go @@ -78,3 +78,18 @@ func TestLightweightSummaries(t *testing.T) { } }) } + +func TestRunFromOverride(t *testing.T) { + scenarioDB.RunAllWithATwist(t, TwistAddRunFrom, func(t *testing.T, mtr *framework.MonitorTestRun, err error) { + for _, e := range mtr.Events() { + testslike.Test(t, lookslike.MustCompile(map[string]interface{}{ + "observer": map[string]interface{}{ + "name": TestLocationDefault.ID, + "geo": map[string]interface{}{ + "name": TestLocationDefault.Geo.Name, + }, + }, + }), e.Fields) + } + }) +} diff --git a/x-pack/heartbeat/scenarios/framework/fakeloader.go b/x-pack/heartbeat/scenarios/framework/fakeloader.go index d4637328353b..7e579cd00536 100644 --- a/x-pack/heartbeat/scenarios/framework/fakeloader.go +++ b/x-pack/heartbeat/scenarios/framework/fakeloader.go @@ -27,8 +27,8 @@ func newLoaderDB() *loaderDB { } func loaderDbKey(sf stdfields.StdMonitorFields) string { - if sf.Location != nil { - return fmt.Sprintf("%s-%s", sf.ID, sf.Location.ID) + if sf.RunFrom != nil { + return fmt.Sprintf("%s-%s", sf.ID, sf.RunFrom.ID) } return sf.ID } diff --git a/x-pack/heartbeat/scenarios/framework/framework.go b/x-pack/heartbeat/scenarios/framework/framework.go index b538ae70d70c..0bc3c46c451d 100644 --- a/x-pack/heartbeat/scenarios/framework/framework.go +++ b/x-pack/heartbeat/scenarios/framework/framework.go @@ -37,7 +37,7 @@ type Scenario struct { Type string Runner ScenarioRun Tags []string - Location *hbconfig.LocationWithID + RunFrom *hbconfig.LocationWithID NumberOfRuns int } @@ -63,9 +63,9 @@ func MultiTwist(twists ...Twist) Twist { func (s Scenario) clone() Scenario { copy := s - if s.Location != nil { - locationCopy := *s.Location - copy.Location = &locationCopy + if s.RunFrom != nil { + locationCopy := *s.RunFrom + copy.RunFrom = &locationCopy } return copy } @@ -102,7 +102,7 @@ func (s Scenario) Run(t *testing.T, twist Twist, callback func(t *testing.T, mtr var conf mapstr.M for i := 0; i < numberRuns; i++ { var mtr *MonitorTestRun - mtr, err = runMonitorOnce(t, cfgMap, runS.Location, loaderDB.StateLoader()) + mtr, err = runMonitorOnce(t, cfgMap, runS.RunFrom, loaderDB.StateLoader()) mtr.wait() events = append(events, mtr.Events()...) diff --git a/x-pack/heartbeat/scenarios/framework/framework_test.go b/x-pack/heartbeat/scenarios/framework/framework_test.go index fc5e3e632a6f..97316106e7fb 100644 --- a/x-pack/heartbeat/scenarios/framework/framework_test.go +++ b/x-pack/heartbeat/scenarios/framework/framework_test.go @@ -25,7 +25,7 @@ var testScenario Scenario = Scenario{ "schedule": "@every 10s", }, nil, nil }, - Location: &config.LocationWithID{ + RunFrom: &config.LocationWithID{ ID: "TestID", Geo: util.GeoConfig{ Name: "TestName", @@ -39,9 +39,9 @@ func TestClone(t *testing.T) { require.NotEqual(t, testScenario.Name, clone.Name) clone.Tags = []string{"CloneTag"} require.NotEqual(t, testScenario.Tags, clone.Tags) - clone.Location.ID = "CloneID" - require.NotEqual(t, testScenario.Location.ID, clone.Location.ID) - clone.Location.Geo.Name = "CloneGeoName" - require.NotEqual(t, testScenario.Location.Geo.Name, clone.Location.Geo.Name) + clone.RunFrom.ID = "CloneID" + require.NotEqual(t, testScenario.RunFrom.ID, clone.RunFrom.ID) + clone.RunFrom.Geo.Name = "CloneGeoName" + require.NotEqual(t, testScenario.RunFrom.Geo.Name, clone.RunFrom.Geo.Name) } diff --git a/x-pack/heartbeat/scenarios/stateloader_test.go b/x-pack/heartbeat/scenarios/stateloader_test.go index fd5a9055d351..79cd2abf0b4b 100644 --- a/x-pack/heartbeat/scenarios/stateloader_test.go +++ b/x-pack/heartbeat/scenarios/stateloader_test.go @@ -13,7 +13,7 @@ import ( "github.com/elastic/beats/v7/x-pack/heartbeat/scenarios/framework" ) -var esIntegTwists = framework.MultiTwist(TwistAddLocation, TwistMultiRun(3)) +var esIntegTwists = framework.MultiTwist(TwistAddRunFrom, TwistMultiRun(3)) func TestStateContinuity(t *testing.T) { scenarioDB.RunAllWithATwist(t, esIntegTwists, func(t *testing.T, mtr *framework.MonitorTestRun, err error) { diff --git a/x-pack/heartbeat/scenarios/twists.go b/x-pack/heartbeat/scenarios/twists.go index 8d7c0188f377..f612aa2c61f2 100644 --- a/x-pack/heartbeat/scenarios/twists.go +++ b/x-pack/heartbeat/scenarios/twists.go @@ -22,8 +22,8 @@ var TestLocationMpls = &config.LocationWithID{ }, } -var TwistAddLocation = framework.MakeTwist("add location", func(s framework.Scenario) framework.Scenario { - s.Location = TestLocationDefault +var TwistAddRunFrom = framework.MakeTwist("add run_from", func(s framework.Scenario) framework.Scenario { + s.RunFrom = TestLocationDefault return s }) From a404afa89e63efef54ba9589f4ff0c84d2f2b758 Mon Sep 17 00:00:00 2001 From: Andrew Cholakian Date: Tue, 13 Sep 2022 15:22:24 -0500 Subject: [PATCH 102/102] Incorporate PR feedback --- heartbeat/beater/heartbeat.go | 4 ++-- heartbeat/config/config.go | 2 +- heartbeat/monitors/factory.go | 4 ++-- .../wrappers/monitorstate/monitorstate.go | 10 +++++++++- .../scenarios/framework/fakeloader.go | 18 +++++++----------- .../heartbeat/scenarios/framework/framework.go | 2 +- 6 files changed, 22 insertions(+), 18 deletions(-) diff --git a/heartbeat/beater/heartbeat.go b/heartbeat/beater/heartbeat.go index 013083dcf9c0..5b9f862e4cb5 100644 --- a/heartbeat/beater/heartbeat.go +++ b/heartbeat/beater/heartbeat.go @@ -76,7 +76,7 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { return nil, err } if esc != nil { - stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*", parsedConfig.Location) + stateLoader = monitorstate.MakeESLoader(esc, "synthetics-*,heartbeat-*", parsedConfig.RunFrom) } } @@ -118,7 +118,7 @@ func New(b *beat.Beat, rawConfig *conf.C) (beat.Beater, error) { StateLoader: stateLoader, PluginsReg: plugin.GlobalPluginsReg, PipelineClientFactory: pipelineClientFactory, - BeatLocation: parsedConfig.Location, + BeatRunFrom: parsedConfig.RunFrom, }), } return bt, nil diff --git a/heartbeat/config/config.go b/heartbeat/config/config.go index 0acbd0f56f32..d6f33bd6a4d4 100644 --- a/heartbeat/config/config.go +++ b/heartbeat/config/config.go @@ -39,7 +39,7 @@ type Config struct { Scheduler Scheduler `config:"scheduler"` Autodiscover *autodiscover.Config `config:"autodiscover"` Jobs map[string]*JobLimit `config:"jobs"` - Location *LocationWithID `config:"location"` + RunFrom *LocationWithID `config:"run_from"` } type JobLimit struct { diff --git a/heartbeat/monitors/factory.go b/heartbeat/monitors/factory.go index c293ac6922c5..88fd048b2a99 100644 --- a/heartbeat/monitors/factory.go +++ b/heartbeat/monitors/factory.go @@ -83,7 +83,7 @@ type FactoryParams struct { StateLoader monitorstate.StateLoader PluginsReg *plugin.PluginsReg PipelineClientFactory PipelineClientFactory - BeatLocation *config.LocationWithID + BeatRunFrom *config.LocationWithID } // NewFactory takes a scheduler and creates a RunnerFactory that can create cfgfile.Runner(Monitor) objects. @@ -96,7 +96,7 @@ func NewFactory(fp FactoryParams) *RunnerFactory { pluginsReg: fp.PluginsReg, logger: logp.L(), pipelineClientFactory: fp.PipelineClientFactory, - beatLocation: fp.BeatLocation, + beatLocation: fp.BeatRunFrom, stateLoader: fp.StateLoader, } } diff --git a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go index 432cb4b97e82..1de1d78a9fb7 100644 --- a/heartbeat/monitors/wrappers/monitorstate/monitorstate.go +++ b/heartbeat/monitors/wrappers/monitorstate/monitorstate.go @@ -44,7 +44,7 @@ func newMonitorState(sf stdfields.StdMonitorFields, status StateStatus, ctr int, // ID is unique and sortable by time for easier aggregations // Note that we add an incrementing counter to help with the fact that // millisecond res isn't quite enough for uniqueness (esp. in tests) - ID: fmt.Sprintf("%s-%s-%x-%x", sf.ID, sf.RunFrom, now.UnixMilli(), ctr), + ID: LoaderDBKey(sf, now, ctr), StartedAt: now, DurationMs: 0, Status: status, @@ -161,3 +161,11 @@ func (s *State) copy() *State { copy(copied.FlapHistory, s.FlapHistory) return &copied } + +func LoaderDBKey(sf stdfields.StdMonitorFields, at time.Time, ctr int) string { + rfid := "default" + if sf.RunFrom != nil { + rfid = sf.RunFrom.ID + } + return fmt.Sprintf("%s-%s-%x-%x", sf.ID, rfid, at.UnixMilli(), ctr) +} diff --git a/x-pack/heartbeat/scenarios/framework/fakeloader.go b/x-pack/heartbeat/scenarios/framework/fakeloader.go index 7e579cd00536..8864989a92e1 100644 --- a/x-pack/heartbeat/scenarios/framework/fakeloader.go +++ b/x-pack/heartbeat/scenarios/framework/fakeloader.go @@ -5,8 +5,8 @@ package framework import ( - "fmt" "sync" + "time" "github.com/elastic/beats/v7/heartbeat/monitors/stdfields" "github.com/elastic/beats/v7/heartbeat/monitors/wrappers/monitorstate" @@ -17,6 +17,7 @@ import ( type loaderDB struct { keysToState map[string]*monitorstate.State mtx *sync.Mutex + lastTime time.Time } func newLoaderDB() *loaderDB { @@ -26,25 +27,20 @@ func newLoaderDB() *loaderDB { } } -func loaderDbKey(sf stdfields.StdMonitorFields) string { - if sf.RunFrom != nil { - return fmt.Sprintf("%s-%s", sf.ID, sf.RunFrom.ID) - } - return sf.ID -} - func (ldb loaderDB) AddState(sf stdfields.StdMonitorFields, state *monitorstate.State) { ldb.mtx.Lock() defer ldb.mtx.Unlock() - ldb.keysToState[loaderDbKey(sf)] = state + ldb.lastTime = time.Now() + + ldb.keysToState[monitorstate.LoaderDBKey(sf, ldb.lastTime, 0)] = state } func (ldb loaderDB) GetState(sf stdfields.StdMonitorFields) *monitorstate.State { ldb.mtx.Lock() defer ldb.mtx.Unlock() - found := ldb.keysToState[loaderDbKey(sf)] + found := ldb.keysToState[monitorstate.LoaderDBKey(sf, ldb.lastTime, 0)] return found } @@ -53,7 +49,7 @@ func (ldb loaderDB) StateLoader() monitorstate.StateLoader { ldb.mtx.Lock() defer ldb.mtx.Unlock() - found := ldb.keysToState[loaderDbKey(sf)] + found := ldb.keysToState[monitorstate.LoaderDBKey(sf, ldb.lastTime, 0)] return found, nil } } diff --git a/x-pack/heartbeat/scenarios/framework/framework.go b/x-pack/heartbeat/scenarios/framework/framework.go index 0bc3c46c451d..3bde2eed0f75 100644 --- a/x-pack/heartbeat/scenarios/framework/framework.go +++ b/x-pack/heartbeat/scenarios/framework/framework.go @@ -275,7 +275,7 @@ func setupFactoryAndSched(location *hbconfig.LocationWithID, stateLoader monitor c, _ := pipeline.Connect() return monitors.SyncPipelineClientAdaptor{C: c}, nil }, - BeatLocation: location, + BeatRunFrom: location, }), sched, sched.Stop