mirror of
https://github.com/prometheus/prometheus.git
synced 2024-12-28 06:59:40 -08:00
7221228843
This adds `role` field to the Kubernetes SD config, which indicates which type of Kubernetes SD should be run. This no longer allows discovering pods and nodes with the same SD configuration for example.
454 lines
12 KiB
Go
454 lines
12 KiB
Go
// Copyright 2015 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 config
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io/ioutil"
|
|
"net/url"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/prometheus/common/model"
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
var expectedConf = &Config{
|
|
GlobalConfig: GlobalConfig{
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
EvaluationInterval: model.Duration(30 * time.Second),
|
|
|
|
ExternalLabels: model.LabelSet{
|
|
"monitor": "codelab",
|
|
"foo": "bar",
|
|
},
|
|
},
|
|
|
|
RuleFiles: []string{
|
|
"testdata/first.rules",
|
|
"/absolute/second.rules",
|
|
"testdata/my/*.rules",
|
|
},
|
|
|
|
ScrapeConfigs: []*ScrapeConfig{
|
|
{
|
|
JobName: "prometheus",
|
|
|
|
HonorLabels: true,
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
BearerTokenFile: "testdata/valid_token_file",
|
|
|
|
StaticConfigs: []*TargetGroup{
|
|
{
|
|
Targets: []model.LabelSet{
|
|
{model.AddressLabel: "localhost:9090"},
|
|
{model.AddressLabel: "localhost:9191"},
|
|
},
|
|
Labels: model.LabelSet{
|
|
"my": "label",
|
|
"your": "label",
|
|
},
|
|
},
|
|
},
|
|
|
|
FileSDConfigs: []*FileSDConfig{
|
|
{
|
|
Files: []string{"foo/*.slow.json", "foo/*.slow.yml", "single/file.yml"},
|
|
RefreshInterval: model.Duration(10 * time.Minute),
|
|
},
|
|
{
|
|
Files: []string{"bar/*.yaml"},
|
|
RefreshInterval: model.Duration(5 * time.Minute),
|
|
},
|
|
},
|
|
|
|
RelabelConfigs: []*RelabelConfig{
|
|
{
|
|
SourceLabels: model.LabelNames{"job", "__meta_dns_name"},
|
|
TargetLabel: "job",
|
|
Separator: ";",
|
|
Regex: MustNewRegexp("(.*)some-[regex]"),
|
|
Replacement: "foo-${1}",
|
|
Action: RelabelReplace,
|
|
}, {
|
|
SourceLabels: model.LabelNames{"abc"},
|
|
TargetLabel: "cde",
|
|
Separator: ";",
|
|
Regex: DefaultRelabelConfig.Regex,
|
|
Replacement: DefaultRelabelConfig.Replacement,
|
|
Action: RelabelReplace,
|
|
}, {
|
|
TargetLabel: "abc",
|
|
Separator: ";",
|
|
Regex: DefaultRelabelConfig.Regex,
|
|
Replacement: "static",
|
|
Action: RelabelReplace,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-x",
|
|
|
|
ScrapeInterval: model.Duration(50 * time.Second),
|
|
ScrapeTimeout: model.Duration(5 * time.Second),
|
|
|
|
BasicAuth: &BasicAuth{
|
|
Username: "admin_name",
|
|
Password: "admin_password",
|
|
},
|
|
MetricsPath: "/my_path",
|
|
Scheme: "https",
|
|
|
|
DNSSDConfigs: []*DNSSDConfig{
|
|
{
|
|
Names: []string{
|
|
"first.dns.address.domain.com",
|
|
"second.dns.address.domain.com",
|
|
},
|
|
RefreshInterval: model.Duration(15 * time.Second),
|
|
Type: "SRV",
|
|
},
|
|
{
|
|
Names: []string{
|
|
"first.dns.address.domain.com",
|
|
},
|
|
RefreshInterval: model.Duration(30 * time.Second),
|
|
Type: "SRV",
|
|
},
|
|
},
|
|
|
|
RelabelConfigs: []*RelabelConfig{
|
|
{
|
|
SourceLabels: model.LabelNames{"job"},
|
|
Regex: MustNewRegexp("(.*)some-[regex]"),
|
|
Separator: ";",
|
|
Replacement: DefaultRelabelConfig.Replacement,
|
|
Action: RelabelDrop,
|
|
},
|
|
{
|
|
SourceLabels: model.LabelNames{"__address__"},
|
|
TargetLabel: "__tmp_hash",
|
|
Regex: DefaultRelabelConfig.Regex,
|
|
Replacement: DefaultRelabelConfig.Replacement,
|
|
Modulus: 8,
|
|
Separator: ";",
|
|
Action: RelabelHashMod,
|
|
},
|
|
{
|
|
SourceLabels: model.LabelNames{"__tmp_hash"},
|
|
Regex: MustNewRegexp("1"),
|
|
Separator: ";",
|
|
Replacement: DefaultRelabelConfig.Replacement,
|
|
Action: RelabelKeep,
|
|
},
|
|
{
|
|
Regex: MustNewRegexp("1"),
|
|
Separator: ";",
|
|
Replacement: DefaultRelabelConfig.Replacement,
|
|
Action: RelabelLabelMap,
|
|
},
|
|
},
|
|
MetricRelabelConfigs: []*RelabelConfig{
|
|
{
|
|
SourceLabels: model.LabelNames{"__name__"},
|
|
Regex: MustNewRegexp("expensive_metric.*"),
|
|
Separator: ";",
|
|
Replacement: DefaultRelabelConfig.Replacement,
|
|
Action: RelabelDrop,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-y",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
ConsulSDConfigs: []*ConsulSDConfig{
|
|
{
|
|
Server: "localhost:1234",
|
|
Services: []string{"nginx", "cache", "mysql"},
|
|
TagSeparator: DefaultConsulSDConfig.TagSeparator,
|
|
Scheme: DefaultConsulSDConfig.Scheme,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-z",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: model.Duration(10 * time.Second),
|
|
|
|
MetricsPath: "/metrics",
|
|
Scheme: "http",
|
|
|
|
TLSConfig: TLSConfig{
|
|
CertFile: "testdata/valid_cert_file",
|
|
KeyFile: "testdata/valid_key_file",
|
|
},
|
|
|
|
BearerToken: "avalidtoken",
|
|
},
|
|
{
|
|
JobName: "service-kubernetes",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
KubernetesSDConfigs: []*KubernetesSDConfig{
|
|
{
|
|
APIServers: []URL{kubernetesSDHostURL()},
|
|
Role: KubernetesRoleEndpoint,
|
|
BasicAuth: &BasicAuth{
|
|
Username: "myusername",
|
|
Password: "mypassword",
|
|
},
|
|
RequestTimeout: model.Duration(10 * time.Second),
|
|
RetryInterval: model.Duration(1 * time.Second),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-marathon",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
MarathonSDConfigs: []*MarathonSDConfig{
|
|
{
|
|
Servers: []string{
|
|
"http://marathon.example.com:8080",
|
|
},
|
|
RefreshInterval: model.Duration(30 * time.Second),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-ec2",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
EC2SDConfigs: []*EC2SDConfig{
|
|
{
|
|
Region: "us-east-1",
|
|
AccessKey: "access",
|
|
SecretKey: "secret",
|
|
RefreshInterval: model.Duration(60 * time.Second),
|
|
Port: 80,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-azure",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
AzureSDConfigs: []*AzureSDConfig{
|
|
{
|
|
SubscriptionID: "11AAAA11-A11A-111A-A111-1111A1111A11",
|
|
TenantID: "BBBB222B-B2B2-2B22-B222-2BB2222BB2B2",
|
|
ClientID: "333333CC-3C33-3333-CCC3-33C3CCCCC33C",
|
|
ClientSecret: "nAdvAK2oBuVym4IXix",
|
|
RefreshInterval: model.Duration(5 * time.Minute),
|
|
Port: 9100,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
JobName: "service-nerve",
|
|
|
|
ScrapeInterval: model.Duration(15 * time.Second),
|
|
ScrapeTimeout: DefaultGlobalConfig.ScrapeTimeout,
|
|
|
|
MetricsPath: DefaultScrapeConfig.MetricsPath,
|
|
Scheme: DefaultScrapeConfig.Scheme,
|
|
|
|
NerveSDConfigs: []*NerveSDConfig{
|
|
{
|
|
Servers: []string{"localhost"},
|
|
Paths: []string{"/monitoring"},
|
|
Timeout: model.Duration(10 * time.Second),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
original: "",
|
|
}
|
|
|
|
func TestLoadConfig(t *testing.T) {
|
|
// Parse a valid file that sets a global scrape timeout. This tests whether parsing
|
|
// an overwritten default field in the global config permanently changes the default.
|
|
if _, err := LoadFile("testdata/global_timeout.good.yml"); err != nil {
|
|
t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err)
|
|
}
|
|
|
|
c, err := LoadFile("testdata/conf.good.yml")
|
|
if err != nil {
|
|
t.Fatalf("Error parsing %s: %s", "testdata/conf.good.yml", err)
|
|
}
|
|
|
|
bgot, err := yaml.Marshal(c)
|
|
if err != nil {
|
|
t.Fatalf("%s", err)
|
|
}
|
|
|
|
bexp, err := yaml.Marshal(expectedConf)
|
|
if err != nil {
|
|
t.Fatalf("%s", err)
|
|
}
|
|
expectedConf.original = c.original
|
|
|
|
if !reflect.DeepEqual(c, expectedConf) {
|
|
t.Fatalf("%s: unexpected config result: \n\n%s\n expected\n\n%s", "testdata/conf.good.yml", bgot, bexp)
|
|
}
|
|
|
|
// String method must not reveal authentication credentials.
|
|
s := c.String()
|
|
if strings.Contains(s, "admin_password") {
|
|
t.Fatalf("config's String method reveals authentication credentials.")
|
|
}
|
|
}
|
|
|
|
var expectedErrors = []struct {
|
|
filename string
|
|
errMsg string
|
|
}{
|
|
{
|
|
filename: "jobname.bad.yml",
|
|
errMsg: `"prom^etheus" is not a valid job name`,
|
|
}, {
|
|
filename: "jobname_dup.bad.yml",
|
|
errMsg: `found multiple scrape configs with job name "prometheus"`,
|
|
}, {
|
|
filename: "scrape_interval.bad.yml",
|
|
errMsg: `scrape timeout greater than scrape interval`,
|
|
}, {
|
|
filename: "labelname.bad.yml",
|
|
errMsg: `"not$allowed" is not a valid label name`,
|
|
}, {
|
|
filename: "labelname2.bad.yml",
|
|
errMsg: `"not:allowed" is not a valid label name`,
|
|
}, {
|
|
filename: "regex.bad.yml",
|
|
errMsg: "error parsing regexp",
|
|
}, {
|
|
filename: "modulus_missing.bad.yml",
|
|
errMsg: "relabel configuration for hashmod requires non-zero modulus",
|
|
}, {
|
|
filename: "rules.bad.yml",
|
|
errMsg: "invalid rule file path",
|
|
}, {
|
|
filename: "unknown_attr.bad.yml",
|
|
errMsg: "unknown fields in scrape_config: consult_sd_configs",
|
|
}, {
|
|
filename: "bearertoken.bad.yml",
|
|
errMsg: "at most one of bearer_token & bearer_token_file must be configured",
|
|
}, {
|
|
filename: "bearertoken_basicauth.bad.yml",
|
|
errMsg: "at most one of basic_auth, bearer_token & bearer_token_file must be configured",
|
|
}, {
|
|
filename: "kubernetes_bearertoken.bad.yml",
|
|
errMsg: "at most one of bearer_token & bearer_token_file must be configured",
|
|
}, {
|
|
filename: "kubernetes_bearertoken_basicauth.bad.yml",
|
|
errMsg: "at most one of basic_auth, bearer_token & bearer_token_file must be configured",
|
|
}, {
|
|
filename: "marathon_no_servers.bad.yml",
|
|
errMsg: "Marathon SD config must contain at least one Marathon server",
|
|
}, {
|
|
filename: "url_in_targetgroup.bad.yml",
|
|
errMsg: "\"http://bad\" is not a valid hostname",
|
|
},
|
|
}
|
|
|
|
func TestBadConfigs(t *testing.T) {
|
|
for _, ee := range expectedErrors {
|
|
_, err := LoadFile("testdata/" + ee.filename)
|
|
if err == nil {
|
|
t.Errorf("Expected error parsing %s but got none", ee.filename)
|
|
continue
|
|
}
|
|
if !strings.Contains(err.Error(), ee.errMsg) {
|
|
t.Errorf("Expected error for %s to contain %q but got: %s", ee.filename, ee.errMsg, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBadStaticConfigs(t *testing.T) {
|
|
content, err := ioutil.ReadFile("testdata/static_config.bad.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var tg TargetGroup
|
|
err = json.Unmarshal(content, &tg)
|
|
if err == nil {
|
|
t.Errorf("Expected unmarshal error but got none.")
|
|
}
|
|
}
|
|
|
|
func TestEmptyConfig(t *testing.T) {
|
|
c, err := Load("")
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error parsing empty config file: %s", err)
|
|
}
|
|
exp := DefaultConfig
|
|
|
|
if !reflect.DeepEqual(*c, exp) {
|
|
t.Fatalf("want %v, got %v", exp, c)
|
|
}
|
|
}
|
|
|
|
func TestEmptyGlobalBlock(t *testing.T) {
|
|
c, err := Load("global:\n")
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error parsing empty config file: %s", err)
|
|
}
|
|
exp := DefaultConfig
|
|
exp.original = "global:\n"
|
|
|
|
if !reflect.DeepEqual(*c, exp) {
|
|
t.Fatalf("want %v, got %v", exp, c)
|
|
}
|
|
}
|
|
|
|
func kubernetesSDHostURL() URL {
|
|
tURL, _ := url.Parse("https://localhost:1234")
|
|
return URL{URL: tURL}
|
|
}
|