Experiment: Schematized Metrics

config/config.go

@@ -33,8 +33,8 @@ import (
 
 	"github.com/alecthomas/units"
 	"github.com/miekg/dns"
+	configmetrics "github.com/prometheus/blackbox_exporter/internal/metrics/config"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prometheus/common/config"
 )
 
@@ -90,18 +90,17 @@ type SafeConfig struct {
 }
 
 func NewSafeConfig(reg prometheus.Registerer) *SafeConfig {
-	configReloadSuccess := promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-		Namespace: "blackbox_exporter",
-		Name:      "config_last_reload_successful",
-		Help:      "Blackbox exporter config loaded successfully.",
-	})
+	configReloadSuccessMetric := configmetrics.NewLastReloadSuccessful()
+	configReloadSecondsMetric := configmetrics.NewLastReloadSuccessTimestampSeconds()
 
-	configReloadSeconds := promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-		Namespace: "blackbox_exporter",
-		Name:      "config_last_reload_success_timestamp_seconds",
-		Help:      "Timestamp of the last successful configuration reload.",
-	})
-	return &SafeConfig{C: &Config{}, configReloadSuccess: configReloadSuccess, configReloadSeconds: configReloadSeconds}
+	reg.MustRegister(configReloadSuccessMetric)
+	reg.MustRegister(configReloadSecondsMetric)
+
+	return &SafeConfig{
+		C:                   &Config{},
+		configReloadSuccess: configReloadSuccessMetric,
+		configReloadSeconds: configReloadSecondsMetric,
+	}
 }
 
 func (sc *SafeConfig) ReloadConfig(confFile string, logger *slog.Logger) (err error) {

internal/metrics/blackbox/metric_blackbox_module_unknown.go

@@ -0,0 +1,27 @@
+package blackbox
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Count of unknown modules requested by probes
+type ModuleUnknown struct {
+	prometheus.Counter
+}
+
+func NewModuleUnknown() ModuleUnknown {
+	return ModuleUnknown{Counter: prometheus.NewCounter(prometheus.CounterOpts{
+		Name: "blackbox_module_unknown_total",
+		Help: "Count of unknown modules requested by probes",
+	})}
+}
+
+func (m ModuleUnknown) Register(regs ...prometheus.Registerer) ModuleUnknown {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/config/metric_config_last_reload_success_timestamp_seconds.go

@@ -0,0 +1,27 @@
+package config
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Timestamp of the last successful configuration reload
+type LastReloadSuccessTimestampSeconds struct {
+	prometheus.Gauge
+}
+
+func NewLastReloadSuccessTimestampSeconds() LastReloadSuccessTimestampSeconds {
+	return LastReloadSuccessTimestampSeconds{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "blackbox_exporter_config_last_reload_success_timestamp_seconds",
+		Help: "Timestamp of the last successful configuration reload",
+	})}
+}
+
+func (m LastReloadSuccessTimestampSeconds) Register(regs ...prometheus.Registerer) LastReloadSuccessTimestampSeconds {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/config/metric_config_last_reload_successful.go

@@ -0,0 +1,27 @@
+package config
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Blackbox exporter config loaded successfully
+type LastReloadSuccessful struct {
+	prometheus.Gauge
+}
+
+func NewLastReloadSuccessful() LastReloadSuccessful {
+	return LastReloadSuccessful{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "blackbox_exporter_config_last_reload_successful",
+		Help: "Blackbox exporter config loaded successfully",
+	})}
+}
+
+func (m LastReloadSuccessful) Register(regs ...prometheus.Registerer) LastReloadSuccessful {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/dns/metric_dns_probe_additional_rrs.go

@@ -0,0 +1,27 @@
+package dns
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Returns number of entries in the additional resource record list
+type ProbeAdditionalRrs struct {
+	prometheus.Gauge
+}
+
+func NewProbeAdditionalRrs() ProbeAdditionalRrs {
+	return ProbeAdditionalRrs{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "probe_dns_additional_rrs",
+		Help: "Returns number of entries in the additional resource record list",
+	})}
+}
+
+func (m ProbeAdditionalRrs) Register(regs ...prometheus.Registerer) ProbeAdditionalRrs {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/dns/metric_dns_probe_answer_rrs.go

@@ -0,0 +1,27 @@
+package dns
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Returns number of entries in the answer resource record list
+type ProbeAnswerRrs struct {
+	prometheus.Gauge
+}
+
+func NewProbeAnswerRrs() ProbeAnswerRrs {
+	return ProbeAnswerRrs{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "probe_dns_answer_rrs",
+		Help: "Returns number of entries in the answer resource record list",
+	})}
+}
+
+func (m ProbeAnswerRrs) Register(regs ...prometheus.Registerer) ProbeAnswerRrs {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/dns/metric_dns_probe_authority_rrs.go

@@ -0,0 +1,27 @@
+package dns
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Returns number of entries in the authority resource record list
+type ProbeAuthorityRrs struct {
+	prometheus.Gauge
+}
+
+func NewProbeAuthorityRrs() ProbeAuthorityRrs {
+	return ProbeAuthorityRrs{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "probe_dns_authority_rrs",
+		Help: "Returns number of entries in the authority resource record list",
+	})}
+}
+
+func (m ProbeAuthorityRrs) Register(regs ...prometheus.Registerer) ProbeAuthorityRrs {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/dns/metric_dns_probe_duration_seconds.go

@@ -0,0 +1,35 @@
+package dns
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+import (
+	"github.com/prometheus/blackbox_exporter/internal/metrics/other"
+)
+
+// Duration of DNS request by phase
+type ProbeDurationSeconds struct {
+	*prometheus.GaugeVec
+	extra ProbeDurationSecondsExtra
+}
+
+func NewProbeDurationSeconds() ProbeDurationSeconds {
+	labels := []string{other.AttrPhase("").Key()}
+	return ProbeDurationSeconds{GaugeVec: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "probe_dns_duration_seconds",
+		Help: "Duration of DNS request by phase",
+	}, labels)}
+}
+
+func (m ProbeDurationSeconds) With(phase other.AttrPhase, extras ...interface{}) prometheus.Gauge {
+	return m.GaugeVec.WithLabelValues(phase.Value())
+}
+
+// Deprecated: Use [ProbeDurationSeconds.With] instead
+func (m ProbeDurationSeconds) WithLabelValues(lvs ...string) prometheus.Gauge {
+	return m.GaugeVec.WithLabelValues(lvs...)
+}
+
+type ProbeDurationSecondsExtra struct {
+}

internal/metrics/dns/metric_dns_probe_query_succeeded.go

@@ -0,0 +1,27 @@
+package dns
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Displays whether or not the query was executed successfully
+type ProbeQuerySucceeded struct {
+	prometheus.Gauge
+}
+
+func NewProbeQuerySucceeded() ProbeQuerySucceeded {
+	return ProbeQuerySucceeded{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "probe_dns_query_succeeded",
+		Help: "Displays whether or not the query was executed successfully",
+	})}
+}
+
+func (m ProbeQuerySucceeded) Register(regs ...prometheus.Registerer) ProbeQuerySucceeded {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/dns/metric_dns_probe_serial.go

@@ -0,0 +1,27 @@
+package dns
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Returns the serial number of the zone
+type ProbeSerial struct {
+	prometheus.Gauge
+}
+
+func NewProbeSerial() ProbeSerial {
+	return ProbeSerial{Gauge: prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "probe_dns_serial",
+		Help: "Returns the serial number of the zone",
+	})}
+}
+
+func (m ProbeSerial) Register(regs ...prometheus.Registerer) ProbeSerial {
+	if regs == nil {
+		prometheus.DefaultRegisterer.MustRegister(m)
+	}
+	for _, reg := range regs {
+		reg.MustRegister(m)
+	}
+	return m
+}

internal/metrics/generate.go

@@ -0,0 +1,4 @@
+package metrics
+
+//go:generate weaver registry generate --registry=../../semconv --templates=/home/tbraack/work/promconv/templates --param module=github.com/prometheus/blackbox_exporter/internal/metrics go .
+//go:generate gofmt -s -w .

internal/metrics/grpc/metric_grpc_probe_duration_seconds.go

@@ -0,0 +1,35 @@
+package grpc
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+import (
+	"github.com/prometheus/blackbox_exporter/internal/metrics/other"
+)
+
+// Duration of gRPC request by phase
+type ProbeDurationSeconds struct {
+	*prometheus.GaugeVec
+	extra ProbeDurationSecondsExtra
+}
+
+func NewProbeDurationSeconds() ProbeDurationSeconds {
+	labels := []string{other.AttrPhase("").Key()}
+	return ProbeDurationSeconds{GaugeVec: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "probe_grpc_duration_seconds",
+		Help: "Duration of gRPC request by phase",
+	}, labels)}
+}
+
+func (m ProbeDurationSeconds) With(phase other.AttrPhase, extras ...interface{}) prometheus.Gauge {
+	return m.GaugeVec.WithLabelValues(phase.Value())
+}
+
+// Deprecated: Use [ProbeDurationSeconds.With] instead
+func (m ProbeDurationSeconds) WithLabelValues(lvs ...string) prometheus.Gauge {
+	return m.GaugeVec.WithLabelValues(lvs...)
+}
+
+type ProbeDurationSecondsExtra struct {
+}

internal/metrics/grpc/metric_grpc_probe_healthcheck_response.go

@@ -0,0 +1,35 @@
+package grpc
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+import (
+	"github.com/prometheus/blackbox_exporter/internal/metrics/other"
+)
+
+// Response HealthCheck response
+type ProbeHealthcheckResponse struct {
+	*prometheus.GaugeVec
+	extra ProbeHealthcheckResponseExtra
+}
+
+func NewProbeHealthcheckResponse() ProbeHealthcheckResponse {
+	labels := []string{other.AttrServingStatus("").Key()}
+	return ProbeHealthcheckResponse{GaugeVec: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "probe_grpc_healthcheck_response",
+		Help: "Response HealthCheck response",
+	}, labels)}
+}
+
+func (m ProbeHealthcheckResponse) With(servingStatus other.AttrServingStatus, extras ...interface{}) prometheus.Gauge {
+	return m.GaugeVec.WithLabelValues(servingStatus.Value())
+}
+
+// Deprecated: Use [ProbeHealthcheckResponse.With] instead
+func (m ProbeHealthcheckResponse) WithLabelValues(lvs ...string) prometheus.Gauge {
+	return m.GaugeVec.WithLabelValues(lvs...)
+}
+
+type ProbeHealthcheckResponseExtra struct {
+}