blackbox_exporter源码阅读
blackbox_exporter是Prometheus监控系统中用于在agent机器上采集http，DNS,ICMP相关信息，通过prometheus传递的参数和target，映射到对应的agent的web接口上进行处理。比如下面的采集配置来自于prometheus的配置文件
scrape_configs:
- job_name: 'blackbox'
metrics_path: /probe
params:
module: [http_2xx] # Look for a HTTP 200 response.
static_configs:
- targets:
- http://prometheus.io # Target to probe with http.
- https://prometheus.io # Target to probe with https.
- http://example.com:8080 # Target to probe with http on port 8080.
relabel_configs:
- source_labels: [__address__]
target_label: __param_target
- source_labels: [__param_target]
target_label: instance
- target_label: __address__
replacement: 127.0.0.1:9115 # The blackbox exporter's real hostname:port.
配置信息中定义了采集的路径，并定义了http传递的参数为module:[http_2xx]并且传递了提供采集的目的机器列表。这与直接发送http请求的效果一致http://localhost:9115/probe?target=http://prometheus.io&module=http_2xx，只不过需要发送多个请求去获得列表的内容。
配置文件导入
配置文件主要用来配置支持的模块及采集的方式，比如我们可以定义dns采集模块dns_udp和dns_tcp分别用来采集target(测试目标机器)对于指定域名的数据采集
dns:
prober: dns
timeout: 5s
dns:
query_type: "A"
query_name: "example.com"
dns_tcp:
prober: dns
timeout: 5s
dns:
transport_protocol: "tcp"
preferred_ip_protocol: "ip4"
query_name: "example.com"
我们可以看下具体的配置文件的导入是如何实现的：
if err := sc.ReloadConfig(*configFile); err != nil {
level.Error(logger).Log("msg", "Error loading config", "err", err)
os.Exit(1)
}
上面的代码执行去导入blackbox.yml(默认配置)的内容，如果导入成功的话，所有的配置信息将保存在sc.C【Config结构体】下面。Config的定义如下。包含了一个map结构，对应了自定义的模块名称及module的配置信息。
type Config struct {
Modules map[string]Module `yaml:"modules"`
// Catches all undefined fields and must be empty after parsing.
XXX map[string]interface{} `yaml:",inline"`
}
module 包含了具体的配置内容，但是为了满足支持的组件，module定义如下。任何一个module中都包含了所有Probe支持的结构体，只需要指定一个组件使用，存储在Prober中，具体的配置则保存在各自的结构体中，比如如果probe: dns则查找配置需要到DNS中去获取。
type Module struct {
Prober string `yaml:"prober,omitempty"`
Timeout time.Duration `yaml:"timeout,omitempty"`
HTTP HTTPProbe `yaml:"http,omitempty"`
TCP TCPProbe `yaml:"tcp,omitempty"`
ICMP ICMPProbe `yaml:"icmp,omitempty"`
DNS DNSProbe `yaml:"dns,omitempty"`
// Catches all undefined fields and must be empty after parsing.
XXX map[string]interface{} `yaml:",inline"`
}
具体的导入工作通过内部实现的不同组件重载yaml模块下的Unmarshaler接口实现yml文件到结构体的导入。比如下面的是DNSProbe结构体的导入。另外checkOverflow用于检查是否有未知的配置写到了配置文件中。
// UnmarshalYAML implements the yaml.Unmarshaler interface.
func (s *DNSProbe) UnmarshalYAML(unmarshal func(interface{}) error) error {
type plain DNSProbe
if err := unmarshal((*plain)(s)); err != nil {
return err
}
if err := checkOverflow(s.XXX, "dns probe"); err != nil {
return err
}
if s.QueryName == "" {
return errors.New("Query name must be set for DNS module")
}
return nil
}
这样导入后的配置Config结构体则包含了所有的自定义模块的信息，包含模块的名称和具体的配置。这样当我们使用接口访问的时候，则通过指定模块名称和target即可实现针对目标对象的采集。
数据采集接口
blackbox_exporter默认情况下的/metrics路径只采集go运行的相关信息,核心的处理逻辑放在了/probe路由处理函数中处理。
http.HandleFunc("/probe", func(w http.ResponseWriter, r *http.Request) {
sc.Lock()
conf := sc.C
sc.Unlock()
probeHandler(w, r, conf, logger, rh)
})
为了防止重载期间对于数据的采集问题，使用锁机制保护访问， 实际调用的函数位于probeHandler中。
func probeHandler(w http.ResponseWriter, r *http.Request, c *config.Config, logger log.Logger, rh *resultHistory) {
moduleName := r.URL.Query().Get("module")
if moduleName == "" {
moduleName = "http_2xx"
}
module, ok := c.Modules[moduleName]
if !ok {
http.Error(w, fmt.Sprintf("Unknown module %q", moduleName), http.StatusBadRequest)
return
}
函数首先查询module参数是否存在，如果不存在则默认使用http_2xx模块（前提是config中配置了该模块）。当获得名称后则查询config.Modules中是否存在对应的模块如果没有的话则返回400错误。
var timeoutSeconds float64
if v := r.Header.Get("X-Prometheus-Scrape-Timeout-Seconds"); v != "" {
var err error
timeoutSeconds, err = strconv.ParseFloat(v, 64)
if err != nil {
http.Error(w, fmt.Sprintf("Failed to parse timeout from Prometheus header: %s", err), http.StatusInternalServerError)
return
}
}
if timeoutSeconds == 0 {
timeoutSeconds = 10
}
if module.Timeout.Seconds() < timeoutSeconds && module.Timeout.Seconds() > 0 {
timeoutSeconds = module.Timeout.Seconds()
}
如果header中指定了采集的超时时间，则使用此值作为超时探测时间，如果没有设置则设置10s，两者取最小值。
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeoutSeconds*float64(time.Second)))
defer cancel()
r = r.WithContext(ctx)
上下文用来管理超时，当超时时间到达后，直接关闭任何的查询连接，并返回。
probeSuccessGauge := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_success",
Help: "Displays whether or not the probe was a success",
})
probeDurationGauge := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_duration_seconds",
Help: "Returns how long the probe took to complete in seconds",
})
params := r.URL.Query()
target := params.Get("target")
if target == "" {
http.Error(w, "Target parameter is missing", http.StatusBadRequest)
return
}
定义基本的采集指标，这两个指标不管是任何配置模块，均会输出在结果中，用来记录是否成功，以及采集时间。获取target的参数，如果没有设置target，同样退出。
prober, ok := Probers[module.Prober]
if !ok {
http.Error(w, fmt.Sprintf("Unknown prober %q", module.Prober), http.StatusBadRequest)
return
}
根据配置中定义的Prober名称获得具体的模块配置。比如Prober为dns则查询Probers中DNS的处理函数。去执行后续的操作。
start := time.Now()
registry := prometheus.NewRegistry()
registry.MustRegister(probeSuccessGauge)
registry.MustRegister(probeDurationGauge)
success := prober(ctx, target, module, registry, sl)
duration := time.Since(start).Seconds()
probeDurationGauge.Set(duration)
if success {
probeSuccessGauge.Set(1)
level.Info(sl).Log("msg", "Probe succeeded", "duration_seconds", duration)
} else {
level.Error(sl).Log("msg", "Probe failed", "duration_seconds", duration)
}
具体的查询逻辑，首先注册两个之前定义的指标对象，并执行实际的抓取操作（prober）传递了超时的上下文，查询对象以及loger等参数。通过返回值和时间来设置对应的指标数据。
另外每个不同模块都具有不同的指标内容，这在不同的模块采集过程中定义。
具体采集（DNS模块）
针对不同的模块都有自己实现的采集模块，这里仅以DNS模块的采集实现来看一下代码的具体实现：
func ProbeDNS(ctx context.Context, target string, module config.Module, registry *prometheus.Registry, logger log.Logger) bool {
var dialProtocol string
probeDNSAnswerRRSGauge := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_dns_answer_rrs",
Help: "Returns number of entries in the answer resource record list",
})
probeDNSAuthorityRRSGauge := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_dns_authority_rrs",
Help: "Returns number of entries in the authority resource record list",
})
probeDNSAdditionalRRSGauge := prometheus.NewGauge(prometheus.GaugeOpts{
Name: "probe_dns_additional_rrs",
Help: "Returns number of entries in the additional resource record list",
})
registry.MustRegister(probeDNSAnswerRRSGauge)
registry.MustRegister(probeDNSAuthorityRRSGauge)
registry.MustRegister(probeDNSAdditionalRRSGauge)
函数开头定义和注册了三个Gauge对象,这三个对象用来存储查询的结果（应答记录，权威记录以及其他记录数量）
根据实际的配置比如协议，另外targer如果包含端口则分开主机和端口，默认端口为53. 并通过go-DNS库(github.com/miekg/dns）来实现发送根据配置好的DNS请求。
probeDNSAnswerRRSGauge.Set(float64(len(response.Answer)))
probeDNSAuthorityRRSGauge.Set(float64(len(response.Ns)))
probeDNSAdditionalRRSGauge.Set(float64(len(response.Extra)))
最后更新指标信息。并且如果配置了独立的验证则通过定义的valid函数来执行制定配置的验证信息比如验证响应信息是否符合要求
level.Info(logger).Log("msg", "Validating Answer RRs")
if !validRRs(&response.Answer, &module.DNS.ValidateAnswer, logger) {
level.Error(logger).Log("msg", "Answer RRs validation failed")
return false
}
level.Info(logger).Log("msg", "Validating Authority RRs")
if !validRRs(&response.Ns, &module.DNS.ValidateAuthority, logger) {
level.Error(logger).Log("msg", "Authority RRs validation failed")
return false
}
level.Info(logger).Log("msg", "Validating Additional RRs")
if !validRRs(&response.Extra, &module.DNS.ValidateAdditional, logger) {
level.Error(logger).Log("msg", "Additional RRs validation failed")
return false
}
具体的验证代码如下：
func validRRs(rrs *[]dns.RR, v *config.DNSRRValidator, logger log.Logger) bool {
// Fail the probe if there are no RRs of a given type, but a regexp match is required
// (i.e. FailIfNotMatchesRegexp is set).
if len(*rrs) == 0 && len(v.FailIfNotMatchesRegexp) > 0 {
level.Error(logger).Log("msg", "fail_if_not_matches_regexp specified but no RRs returned")
return false
}
for _, rr := range *rrs {
level.Info(logger).Log("msg", "Validating RR", "rr", rr)
for _, re := range v.FailIfMatchesRegexp {
match, err := regexp.MatchString(re, rr.String())
if err != nil {
level.Error(logger).Log("msg", "Error matching regexp", "regexp", re, "err", err)
return false
}
if match {
level.Error(logger).Log("msg", "RR matched regexp", "regexp", re, "rr", rr)
return false
}
}
for _, re := range v.FailIfNotMatchesRegexp {
match, err := regexp.MatchString(re, rr.String())
if err != nil {
level.Error(logger).Log("msg", "Error matching regexp", "regexp", re, "err", err)
return false
}
if !match {
level.Error(logger).Log("msg", "RR did not match regexp", "regexp", re, "rr", rr)
return false
}
}
}
return true
}
另外black_exporter支持通过web进行reload的方式，以及通过发送SIGNAL的方式进行配置文件的重载。信号的重载模式通过启动一个独立的goroutine来实现，捕获信号，并执行重载操作：
hup := make(chan os.Signal)
reloadCh := make(chan chan error)
signal.Notify(hup, syscall.SIGHUP)
go func() {
for {
select {
case <-hup:
if err := sc.ReloadConfig(*configFile); err != nil {
level.Error(logger).Log("msg", "Error reloading config", "err", err)
continue
}
level.Info(logger).Log("msg", "Reloaded config file")
case rc := <-reloadCh:
if err := sc.ReloadConfig(*configFile); err != nil {
level.Error(logger).Log("msg", "Error reloading config", "err", err)
rc <- err
} else {
level.Info(logger).Log("msg", "Reloaded config file")
rc <- nil
}
}
}
}()
当通过web方式触发的时候，通过向管道发送信号，则实现独立goroutine中的重载操作，重载过程中会阻塞其他的采集工作。
http.HandleFunc("/-/reload",
func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
w.WriteHeader(http.StatusMethodNotAllowed)
fmt.Fprintf(w, "This endpoint requires a POST request.\n")
return
}
rc := make(chan error)
reloadCh <- rc
if err := <-rc; err != nil {
http.Error(w, fmt.Sprintf("failed to reload config: %s", err), http.StatusInternalServerError)
}
})
对于标准的go运行环境的检测通过promhttp.Handler直接实现。
http.Handle(“/metrics”, promhttp.Handler())
这就是black_exporter的具体实现，关于其他模块的实现此处不多描述。