2016-02-23 01:58:16 -08:00
|
|
|
// Copyright 2016 The Prometheus Authors
|
|
|
|
// Licensed 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 retrieval
|
|
|
|
|
|
|
|
import (
|
2017-01-15 08:33:07 -08:00
|
|
|
"bytes"
|
2016-02-28 00:51:02 -08:00
|
|
|
"fmt"
|
2017-01-15 08:33:07 -08:00
|
|
|
"io"
|
|
|
|
"io/ioutil"
|
2016-02-28 14:59:03 -08:00
|
|
|
"net/http"
|
|
|
|
"net/http/httptest"
|
|
|
|
"net/url"
|
2016-02-28 00:51:02 -08:00
|
|
|
"reflect"
|
2016-02-28 14:59:03 -08:00
|
|
|
"strings"
|
2016-02-28 00:51:02 -08:00
|
|
|
"sync"
|
2016-02-23 01:58:16 -08:00
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/prometheus/common/model"
|
2017-01-15 08:33:07 -08:00
|
|
|
"github.com/stretchr/testify/require"
|
2016-02-23 01:58:16 -08:00
|
|
|
"golang.org/x/net/context"
|
|
|
|
|
2016-02-23 02:56:09 -08:00
|
|
|
"github.com/prometheus/prometheus/config"
|
2016-12-29 00:27:30 -08:00
|
|
|
"github.com/prometheus/prometheus/pkg/labels"
|
2016-02-28 00:51:02 -08:00
|
|
|
"github.com/prometheus/prometheus/storage"
|
2016-02-23 01:58:16 -08:00
|
|
|
)
|
|
|
|
|
2016-02-28 00:51:02 -08:00
|
|
|
func TestNewScrapePool(t *testing.T) {
|
|
|
|
var (
|
2016-12-30 12:35:35 -08:00
|
|
|
app = &nopAppendable{}
|
2016-02-28 00:51:02 -08:00
|
|
|
cfg = &config.ScrapeConfig{}
|
2016-11-22 03:48:30 -08:00
|
|
|
sp = newScrapePool(context.Background(), cfg, app)
|
2016-02-28 00:51:02 -08:00
|
|
|
)
|
|
|
|
|
2016-12-30 12:35:35 -08:00
|
|
|
if a, ok := sp.appendable.(*nopAppendable); !ok || a != app {
|
2016-02-28 00:51:02 -08:00
|
|
|
t.Fatalf("Wrong sample appender")
|
|
|
|
}
|
|
|
|
if sp.config != cfg {
|
|
|
|
t.Fatalf("Wrong scrape config")
|
|
|
|
}
|
|
|
|
if sp.newLoop == nil {
|
|
|
|
t.Fatalf("newLoop function not initialized")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type testLoop struct {
|
|
|
|
startFunc func(interval, timeout time.Duration, errc chan<- error)
|
|
|
|
stopFunc func()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l *testLoop) run(interval, timeout time.Duration, errc chan<- error) {
|
|
|
|
l.startFunc(interval, timeout, errc)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l *testLoop) stop() {
|
|
|
|
l.stopFunc()
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestScrapePoolStop(t *testing.T) {
|
|
|
|
sp := &scrapePool{
|
2016-02-28 10:56:18 -08:00
|
|
|
targets: map[uint64]*Target{},
|
|
|
|
loops: map[uint64]loop{},
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
var mtx sync.Mutex
|
2016-02-28 10:56:18 -08:00
|
|
|
stopped := map[uint64]bool{}
|
2016-02-28 00:51:02 -08:00
|
|
|
numTargets := 20
|
|
|
|
|
|
|
|
// Stopping the scrape pool must call stop() on all scrape loops,
|
|
|
|
// clean them and the respective targets up. It must wait until each loop's
|
|
|
|
// stop function returned before returning itself.
|
|
|
|
|
|
|
|
for i := 0; i < numTargets; i++ {
|
|
|
|
t := &Target{
|
2016-12-29 00:27:30 -08:00
|
|
|
labels: labels.FromStrings(model.AddressLabel, fmt.Sprintf("example.com:%d", i)),
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
l := &testLoop{}
|
|
|
|
l.stopFunc = func() {
|
|
|
|
time.Sleep(time.Duration(i*20) * time.Millisecond)
|
|
|
|
|
|
|
|
mtx.Lock()
|
2016-02-28 10:56:18 -08:00
|
|
|
stopped[t.hash()] = true
|
2016-02-28 00:51:02 -08:00
|
|
|
mtx.Unlock()
|
|
|
|
}
|
|
|
|
|
2016-02-28 10:56:18 -08:00
|
|
|
sp.targets[t.hash()] = t
|
|
|
|
sp.loops[t.hash()] = l
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
done := make(chan struct{})
|
|
|
|
stopTime := time.Now()
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
sp.stop()
|
|
|
|
close(done)
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
t.Fatalf("scrapeLoop.stop() did not return as expected")
|
|
|
|
case <-done:
|
|
|
|
// This should have taken at least as long as the last target slept.
|
|
|
|
if time.Since(stopTime) < time.Duration(numTargets*20)*time.Millisecond {
|
|
|
|
t.Fatalf("scrapeLoop.stop() exited before all targets stopped")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mtx.Lock()
|
|
|
|
if len(stopped) != numTargets {
|
|
|
|
t.Fatalf("Expected 20 stopped loops, got %d", len(stopped))
|
|
|
|
}
|
|
|
|
mtx.Unlock()
|
|
|
|
|
|
|
|
if len(sp.targets) > 0 {
|
|
|
|
t.Fatalf("Targets were not cleared on stopping: %d left", len(sp.targets))
|
|
|
|
}
|
|
|
|
if len(sp.loops) > 0 {
|
|
|
|
t.Fatalf("Loops were not cleared on stopping: %d left", len(sp.loops))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestScrapePoolReload(t *testing.T) {
|
|
|
|
var mtx sync.Mutex
|
|
|
|
numTargets := 20
|
|
|
|
|
2016-02-28 10:56:18 -08:00
|
|
|
stopped := map[uint64]bool{}
|
2016-02-28 00:51:02 -08:00
|
|
|
|
|
|
|
reloadCfg := &config.ScrapeConfig{
|
|
|
|
ScrapeInterval: model.Duration(3 * time.Second),
|
|
|
|
ScrapeTimeout: model.Duration(2 * time.Second),
|
|
|
|
}
|
2016-09-14 20:23:28 -07:00
|
|
|
// On starting to run, new loops created on reload check whether their preceding
|
2016-02-28 00:51:02 -08:00
|
|
|
// equivalents have been stopped.
|
2017-01-13 05:48:01 -08:00
|
|
|
newLoop := func(ctx context.Context, s scraper, app, reportApp func() storage.Appender) loop {
|
2016-02-28 00:51:02 -08:00
|
|
|
l := &testLoop{}
|
|
|
|
l.startFunc = func(interval, timeout time.Duration, errc chan<- error) {
|
|
|
|
if interval != 3*time.Second {
|
|
|
|
t.Errorf("Expected scrape interval %d but got %d", 3*time.Second, interval)
|
|
|
|
}
|
|
|
|
if timeout != 2*time.Second {
|
|
|
|
t.Errorf("Expected scrape timeout %d but got %d", 2*time.Second, timeout)
|
|
|
|
}
|
|
|
|
mtx.Lock()
|
2016-02-28 10:56:18 -08:00
|
|
|
if !stopped[s.(*targetScraper).hash()] {
|
2016-02-28 10:21:50 -08:00
|
|
|
t.Errorf("Scrape loop for %v not stopped yet", s.(*targetScraper))
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
mtx.Unlock()
|
|
|
|
}
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
sp := &scrapePool{
|
2016-12-30 12:35:35 -08:00
|
|
|
appendable: &nopAppendable{},
|
|
|
|
targets: map[uint64]*Target{},
|
|
|
|
loops: map[uint64]loop{},
|
|
|
|
newLoop: newLoop,
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Reloading a scrape pool with a new scrape configuration must stop all scrape
|
2016-09-14 20:23:28 -07:00
|
|
|
// loops and start new ones. A new loop must not be started before the preceding
|
2016-02-28 00:51:02 -08:00
|
|
|
// one terminated.
|
|
|
|
|
|
|
|
for i := 0; i < numTargets; i++ {
|
|
|
|
t := &Target{
|
2016-12-29 00:27:30 -08:00
|
|
|
labels: labels.FromStrings(model.AddressLabel, fmt.Sprintf("example.com:%d", i)),
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
l := &testLoop{}
|
|
|
|
l.stopFunc = func() {
|
|
|
|
time.Sleep(time.Duration(i*20) * time.Millisecond)
|
|
|
|
|
|
|
|
mtx.Lock()
|
2016-02-28 10:56:18 -08:00
|
|
|
stopped[t.hash()] = true
|
2016-02-28 00:51:02 -08:00
|
|
|
mtx.Unlock()
|
|
|
|
}
|
|
|
|
|
2016-02-28 10:56:18 -08:00
|
|
|
sp.targets[t.hash()] = t
|
|
|
|
sp.loops[t.hash()] = l
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
done := make(chan struct{})
|
|
|
|
|
2016-02-28 10:56:18 -08:00
|
|
|
beforeTargets := map[uint64]*Target{}
|
|
|
|
for h, t := range sp.targets {
|
|
|
|
beforeTargets[h] = t
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
reloadTime := time.Now()
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
sp.reload(reloadCfg)
|
|
|
|
close(done)
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
t.Fatalf("scrapeLoop.reload() did not return as expected")
|
|
|
|
case <-done:
|
|
|
|
// This should have taken at least as long as the last target slept.
|
|
|
|
if time.Since(reloadTime) < time.Duration(numTargets*20)*time.Millisecond {
|
|
|
|
t.Fatalf("scrapeLoop.stop() exited before all targets stopped")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mtx.Lock()
|
|
|
|
if len(stopped) != numTargets {
|
2016-05-01 14:37:45 -07:00
|
|
|
t.Fatalf("Expected 20 stopped loops, got %d", len(stopped))
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
mtx.Unlock()
|
|
|
|
|
|
|
|
if !reflect.DeepEqual(sp.targets, beforeTargets) {
|
|
|
|
t.Fatalf("Reloading affected target states unexpectedly")
|
|
|
|
}
|
|
|
|
if len(sp.loops) != numTargets {
|
|
|
|
t.Fatalf("Expected %d loops after reload but got %d", numTargets, len(sp.loops))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-23 02:56:09 -08:00
|
|
|
func TestScrapePoolReportAppender(t *testing.T) {
|
|
|
|
cfg := &config.ScrapeConfig{
|
|
|
|
MetricRelabelConfigs: []*config.RelabelConfig{
|
|
|
|
{}, {}, {},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
target := newTestTarget("example.com:80", 10*time.Millisecond, nil)
|
2016-12-30 12:35:35 -08:00
|
|
|
app := &nopAppendable{}
|
2016-02-23 02:56:09 -08:00
|
|
|
|
2016-11-22 03:48:30 -08:00
|
|
|
sp := newScrapePool(context.Background(), cfg, app)
|
2016-02-23 02:56:09 -08:00
|
|
|
|
|
|
|
cfg.HonorLabels = false
|
|
|
|
wrapped := sp.reportAppender(target)
|
|
|
|
|
|
|
|
rl, ok := wrapped.(ruleLabelsAppender)
|
|
|
|
if !ok {
|
|
|
|
t.Fatalf("Expected ruleLabelsAppender but got %T", wrapped)
|
|
|
|
}
|
2016-12-30 12:35:35 -08:00
|
|
|
if _, ok := rl.Appender.(nopAppender); !ok {
|
2016-12-29 00:27:30 -08:00
|
|
|
t.Fatalf("Expected base appender but got %T", rl.Appender)
|
2016-02-23 02:56:09 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
cfg.HonorLabels = true
|
|
|
|
wrapped = sp.reportAppender(target)
|
|
|
|
|
|
|
|
hl, ok := wrapped.(ruleLabelsAppender)
|
|
|
|
if !ok {
|
|
|
|
t.Fatalf("Expected ruleLabelsAppender but got %T", wrapped)
|
|
|
|
}
|
2016-12-30 12:35:35 -08:00
|
|
|
if _, ok := rl.Appender.(nopAppender); !ok {
|
2016-12-29 00:27:30 -08:00
|
|
|
t.Fatalf("Expected base appender but got %T", hl.Appender)
|
2016-02-23 02:56:09 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestScrapePoolSampleAppender(t *testing.T) {
|
|
|
|
cfg := &config.ScrapeConfig{
|
|
|
|
MetricRelabelConfigs: []*config.RelabelConfig{
|
|
|
|
{}, {}, {},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
target := newTestTarget("example.com:80", 10*time.Millisecond, nil)
|
2016-12-30 12:35:35 -08:00
|
|
|
app := &nopAppendable{}
|
2016-02-23 02:56:09 -08:00
|
|
|
|
2016-11-22 03:48:30 -08:00
|
|
|
sp := newScrapePool(context.Background(), cfg, app)
|
2016-02-23 02:56:09 -08:00
|
|
|
|
|
|
|
cfg.HonorLabels = false
|
|
|
|
wrapped := sp.sampleAppender(target)
|
|
|
|
|
|
|
|
rl, ok := wrapped.(ruleLabelsAppender)
|
|
|
|
if !ok {
|
|
|
|
t.Fatalf("Expected ruleLabelsAppender but got %T", wrapped)
|
|
|
|
}
|
2016-12-29 00:27:30 -08:00
|
|
|
re, ok := rl.Appender.(relabelAppender)
|
2016-02-23 02:56:09 -08:00
|
|
|
if !ok {
|
2016-12-29 00:27:30 -08:00
|
|
|
t.Fatalf("Expected relabelAppender but got %T", rl.Appender)
|
2016-02-23 02:56:09 -08:00
|
|
|
}
|
2016-12-30 12:35:35 -08:00
|
|
|
if _, ok := re.Appender.(nopAppender); !ok {
|
2016-12-29 00:27:30 -08:00
|
|
|
t.Fatalf("Expected base appender but got %T", re.Appender)
|
2016-02-23 02:56:09 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
cfg.HonorLabels = true
|
|
|
|
wrapped = sp.sampleAppender(target)
|
|
|
|
|
|
|
|
hl, ok := wrapped.(honorLabelsAppender)
|
|
|
|
if !ok {
|
|
|
|
t.Fatalf("Expected honorLabelsAppender but got %T", wrapped)
|
|
|
|
}
|
2016-12-29 00:27:30 -08:00
|
|
|
re, ok = hl.Appender.(relabelAppender)
|
2016-02-23 02:56:09 -08:00
|
|
|
if !ok {
|
2016-12-29 00:27:30 -08:00
|
|
|
t.Fatalf("Expected relabelAppender but got %T", hl.Appender)
|
2016-02-23 02:56:09 -08:00
|
|
|
}
|
2016-12-30 12:35:35 -08:00
|
|
|
if _, ok := re.Appender.(nopAppender); !ok {
|
2016-12-29 00:27:30 -08:00
|
|
|
t.Fatalf("Expected base appender but got %T", re.Appender)
|
2016-02-23 02:56:09 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-28 00:51:02 -08:00
|
|
|
func TestScrapeLoopStop(t *testing.T) {
|
|
|
|
scraper := &testScraper{}
|
|
|
|
sl := newScrapeLoop(context.Background(), scraper, nil, nil)
|
|
|
|
|
|
|
|
// The scrape pool synchronizes on stopping scrape loops. However, new scrape
|
|
|
|
// loops are syarted asynchronously. Thus it's possible, that a loop is stopped
|
|
|
|
// again before having started properly.
|
|
|
|
// Stopping not-yet-started loops must block until the run method was called and exited.
|
|
|
|
// The run method must exit immediately.
|
|
|
|
|
|
|
|
stopDone := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
sl.stop()
|
|
|
|
close(stopDone)
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-stopDone:
|
|
|
|
t.Fatalf("Stopping terminated before run exited successfully")
|
|
|
|
case <-time.After(500 * time.Millisecond):
|
|
|
|
}
|
|
|
|
|
|
|
|
// Running the scrape loop must exit before calling the scraper even once.
|
2017-01-15 08:33:07 -08:00
|
|
|
scraper.scrapeFunc = func(context.Context, io.Writer) error {
|
2016-02-28 00:51:02 -08:00
|
|
|
t.Fatalf("scraper was called for terminated scrape loop")
|
2017-01-15 08:33:07 -08:00
|
|
|
return nil
|
2016-02-28 00:51:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
runDone := make(chan struct{})
|
|
|
|
go func() {
|
2016-08-18 00:33:52 -07:00
|
|
|
sl.run(1, 0, nil)
|
2016-02-28 00:51:02 -08:00
|
|
|
close(runDone)
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-runDone:
|
|
|
|
case <-time.After(1 * time.Second):
|
|
|
|
t.Fatalf("Running terminated scrape loop did not exit")
|
|
|
|
}
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-stopDone:
|
|
|
|
case <-time.After(1 * time.Second):
|
|
|
|
t.Fatalf("Stopping did not terminate after running exited")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-23 01:58:16 -08:00
|
|
|
func TestScrapeLoopRun(t *testing.T) {
|
|
|
|
var (
|
|
|
|
signal = make(chan struct{})
|
|
|
|
errc = make(chan error)
|
|
|
|
|
|
|
|
scraper = &testScraper{}
|
2017-01-13 05:48:01 -08:00
|
|
|
app = func() storage.Appender { return &nopAppender{} }
|
|
|
|
reportApp = func() storage.Appender { return &nopAppender{} }
|
2016-02-23 01:58:16 -08:00
|
|
|
)
|
|
|
|
defer close(signal)
|
|
|
|
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
sl := newScrapeLoop(ctx, scraper, app, reportApp)
|
|
|
|
|
|
|
|
// The loop must terminate during the initial offset if the context
|
|
|
|
// is canceled.
|
|
|
|
scraper.offsetDur = time.Hour
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
sl.run(time.Second, time.Hour, errc)
|
|
|
|
signal <- struct{}{}
|
|
|
|
}()
|
|
|
|
|
|
|
|
// Wait to make sure we are actually waiting on the offset.
|
|
|
|
time.Sleep(1 * time.Second)
|
|
|
|
|
|
|
|
cancel()
|
|
|
|
select {
|
|
|
|
case <-signal:
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
t.Fatalf("Cancelation during initial offset failed")
|
|
|
|
case err := <-errc:
|
|
|
|
t.Fatalf("Unexpected error: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// The provided timeout must cause cancelation of the context passed down to the
|
|
|
|
// scraper. The scraper has to respect the context.
|
|
|
|
scraper.offsetDur = 0
|
|
|
|
|
|
|
|
block := make(chan struct{})
|
2017-01-15 08:33:07 -08:00
|
|
|
scraper.scrapeFunc = func(ctx context.Context, _ io.Writer) error {
|
2016-02-23 01:58:16 -08:00
|
|
|
select {
|
|
|
|
case <-block:
|
|
|
|
case <-ctx.Done():
|
2017-01-15 08:33:07 -08:00
|
|
|
return ctx.Err()
|
2016-02-23 01:58:16 -08:00
|
|
|
}
|
2017-01-15 08:33:07 -08:00
|
|
|
return nil
|
2016-02-23 01:58:16 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
ctx, cancel = context.WithCancel(context.Background())
|
|
|
|
sl = newScrapeLoop(ctx, scraper, app, reportApp)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
sl.run(time.Second, 100*time.Millisecond, errc)
|
|
|
|
signal <- struct{}{}
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case err := <-errc:
|
|
|
|
if err != context.DeadlineExceeded {
|
|
|
|
t.Fatalf("Expected timeout error but got: %s", err)
|
|
|
|
}
|
|
|
|
case <-time.After(3 * time.Second):
|
|
|
|
t.Fatalf("Expected timeout error but got none")
|
|
|
|
}
|
|
|
|
|
|
|
|
// We already caught the timeout error and are certainly in the loop.
|
|
|
|
// Let the scrapes returns immediately to cause no further timeout errors
|
|
|
|
// and check whether canceling the parent context terminates the loop.
|
|
|
|
close(block)
|
|
|
|
cancel()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-signal:
|
|
|
|
// Loop terminated as expected.
|
|
|
|
case err := <-errc:
|
|
|
|
t.Fatalf("Unexpected error: %s", err)
|
|
|
|
case <-time.After(3 * time.Second):
|
|
|
|
t.Fatalf("Loop did not terminate on context cancelation")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-28 14:59:03 -08:00
|
|
|
func TestTargetScraperScrapeOK(t *testing.T) {
|
|
|
|
server := httptest.NewServer(
|
|
|
|
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Set("Content-Type", `text/plain; version=0.0.4`)
|
|
|
|
w.Write([]byte("metric_a 1\nmetric_b 2\n"))
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
defer server.Close()
|
|
|
|
|
|
|
|
serverURL, err := url.Parse(server.URL)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
ts := &targetScraper{
|
|
|
|
Target: &Target{
|
2016-12-29 00:27:30 -08:00
|
|
|
labels: labels.FromStrings(
|
|
|
|
model.SchemeLabel, serverURL.Scheme,
|
|
|
|
model.AddressLabel, serverURL.Host,
|
|
|
|
),
|
2016-02-28 14:59:03 -08:00
|
|
|
},
|
|
|
|
client: http.DefaultClient,
|
|
|
|
}
|
2017-01-15 08:33:07 -08:00
|
|
|
var buf bytes.Buffer
|
2016-02-28 14:59:03 -08:00
|
|
|
|
2017-01-15 08:33:07 -08:00
|
|
|
if err := ts.scrape(context.Background(), &buf); err != nil {
|
2016-02-28 14:59:03 -08:00
|
|
|
t.Fatalf("Unexpected scrape error: %s", err)
|
|
|
|
}
|
2017-01-15 08:33:07 -08:00
|
|
|
require.Equal(t, "metric_a 1\nmetric_b 2\n", buf.String())
|
2016-02-28 14:59:03 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestTargetScrapeScrapeCancel(t *testing.T) {
|
|
|
|
block := make(chan struct{})
|
|
|
|
|
|
|
|
server := httptest.NewServer(
|
|
|
|
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
<-block
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
defer server.Close()
|
|
|
|
|
|
|
|
serverURL, err := url.Parse(server.URL)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
ts := &targetScraper{
|
|
|
|
Target: &Target{
|
2016-12-29 00:27:30 -08:00
|
|
|
labels: labels.FromStrings(
|
|
|
|
model.SchemeLabel, serverURL.Scheme,
|
|
|
|
model.AddressLabel, serverURL.Host,
|
|
|
|
),
|
2016-02-28 14:59:03 -08:00
|
|
|
},
|
|
|
|
client: http.DefaultClient,
|
|
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
|
2016-11-13 09:21:42 -08:00
|
|
|
errc := make(chan error)
|
2016-02-28 14:59:03 -08:00
|
|
|
|
|
|
|
go func() {
|
|
|
|
time.Sleep(1 * time.Second)
|
|
|
|
cancel()
|
|
|
|
}()
|
|
|
|
|
|
|
|
go func() {
|
2017-01-15 08:33:07 -08:00
|
|
|
if err := ts.scrape(ctx, ioutil.Discard); err != context.Canceled {
|
2016-11-13 09:21:42 -08:00
|
|
|
errc <- fmt.Errorf("Expected context cancelation error but got: %s", err)
|
2016-02-28 14:59:03 -08:00
|
|
|
}
|
2016-11-13 09:21:42 -08:00
|
|
|
close(errc)
|
2016-02-28 14:59:03 -08:00
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
t.Fatalf("Scrape function did not return unexpectedly")
|
2016-11-13 09:21:42 -08:00
|
|
|
case err := <-errc:
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf(err.Error())
|
|
|
|
}
|
2016-02-28 14:59:03 -08:00
|
|
|
}
|
|
|
|
// If this is closed in a defer above the function the test server
|
|
|
|
// does not terminate and the test doens't complete.
|
|
|
|
close(block)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestTargetScrapeScrapeNotFound(t *testing.T) {
|
|
|
|
server := httptest.NewServer(
|
|
|
|
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
defer server.Close()
|
|
|
|
|
|
|
|
serverURL, err := url.Parse(server.URL)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
ts := &targetScraper{
|
|
|
|
Target: &Target{
|
2016-12-29 00:27:30 -08:00
|
|
|
labels: labels.FromStrings(
|
|
|
|
model.SchemeLabel, serverURL.Scheme,
|
|
|
|
model.AddressLabel, serverURL.Host,
|
|
|
|
),
|
2016-02-28 14:59:03 -08:00
|
|
|
},
|
|
|
|
client: http.DefaultClient,
|
|
|
|
}
|
|
|
|
|
2017-01-15 08:33:07 -08:00
|
|
|
if err := ts.scrape(context.Background(), ioutil.Discard); !strings.Contains(err.Error(), "404") {
|
2016-02-28 14:59:03 -08:00
|
|
|
t.Fatalf("Expected \"404 NotFound\" error but got: %s", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-23 01:58:16 -08:00
|
|
|
// testScraper implements the scraper interface and allows setting values
|
|
|
|
// returned by its methods. It also allows setting a custom scrape function.
|
|
|
|
type testScraper struct {
|
|
|
|
offsetDur time.Duration
|
|
|
|
|
|
|
|
lastStart time.Time
|
|
|
|
lastDuration time.Duration
|
|
|
|
lastError error
|
|
|
|
|
2016-12-29 00:27:30 -08:00
|
|
|
samples samples
|
2016-02-23 01:58:16 -08:00
|
|
|
scrapeErr error
|
2017-01-15 08:33:07 -08:00
|
|
|
scrapeFunc func(context.Context, io.Writer) error
|
2016-02-23 01:58:16 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ts *testScraper) offset(interval time.Duration) time.Duration {
|
|
|
|
return ts.offsetDur
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ts *testScraper) report(start time.Time, duration time.Duration, err error) {
|
|
|
|
ts.lastStart = start
|
|
|
|
ts.lastDuration = duration
|
|
|
|
ts.lastError = err
|
|
|
|
}
|
|
|
|
|
2017-01-15 08:33:07 -08:00
|
|
|
func (ts *testScraper) scrape(ctx context.Context, w io.Writer) error {
|
2016-02-23 01:58:16 -08:00
|
|
|
if ts.scrapeFunc != nil {
|
2017-01-15 08:33:07 -08:00
|
|
|
return ts.scrapeFunc(ctx, w)
|
2016-02-23 01:58:16 -08:00
|
|
|
}
|
2017-01-15 08:33:07 -08:00
|
|
|
return ts.scrapeErr
|
2016-02-23 01:58:16 -08:00
|
|
|
}
|