Migrate scrape package

Signed-off-by: Arthur Silva Sens <arthursens2005@gmail.com>

scrape/metrics.go

@@ -15,286 +15,138 @@ package scrape
 
 import (
 	"fmt"
-	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
+
+	semconv "github.com/prometheus/prometheus/scrape/semconv"
 )
 
 type scrapeMetrics struct {
 	reg prometheus.Registerer
 	// Used by Manager.
 	targetMetadataCache     *MetadataMetricsCollector
-	targetScrapePools       prometheus.Counter
-	targetScrapePoolsFailed prometheus.Counter
+	targetScrapePools       semconv.PrometheusTargetScrapePoolsTotal
+	targetScrapePoolsFailed semconv.PrometheusTargetScrapePoolsFailedTotal
 
 	// Used by scrapePool.
-	targetReloadIntervalLength          *prometheus.SummaryVec
-	targetScrapePoolReloads             prometheus.Counter
-	targetScrapePoolReloadsFailed       prometheus.Counter
-	targetScrapePoolSyncsCounter        *prometheus.CounterVec
-	targetScrapePoolExceededTargetLimit prometheus.Counter
-	targetScrapePoolTargetLimit         *prometheus.GaugeVec
-	targetScrapePoolTargetsAdded        *prometheus.GaugeVec
-	targetScrapePoolSymbolTableItems    *prometheus.GaugeVec
-	targetSyncIntervalLength            *prometheus.SummaryVec
-	targetSyncIntervalLengthHistogram   *prometheus.HistogramVec
-	targetSyncFailed                    *prometheus.CounterVec
+	targetReloadIntervalLength          semconv.PrometheusTargetReloadLengthSeconds
+	targetScrapePoolReloads             semconv.PrometheusTargetScrapePoolReloadsTotal
+	targetScrapePoolReloadsFailed       semconv.PrometheusTargetScrapePoolReloadsFailedTotal
+	targetScrapePoolSyncsCounter        semconv.PrometheusTargetScrapePoolSyncTotal
+	targetScrapePoolExceededTargetLimit semconv.PrometheusTargetScrapePoolExceededTargetLimitTotal
+	targetScrapePoolTargetLimit         semconv.PrometheusTargetScrapePoolTargetLimit
+	targetScrapePoolTargetsAdded        semconv.PrometheusTargetScrapePoolTargets
+	targetScrapePoolSymbolTableItems    semconv.PrometheusTargetScrapePoolSymboltableItems
+	targetSyncIntervalLength            semconv.PrometheusTargetSyncLengthSeconds
+	targetSyncIntervalLengthHistogram   semconv.PrometheusTargetSyncLengthHistogramSeconds
+	targetSyncFailed                    semconv.PrometheusTargetSyncFailedTotal
 
 	// Used by targetScraper.
-	targetScrapeExceededBodySizeLimit prometheus.Counter
+	targetScrapeExceededBodySizeLimit semconv.PrometheusTargetScrapesExceededBodySizeLimitTotal
 
 	// Used by scrapeCache.
-	targetScrapeCacheFlushForced prometheus.Counter
+	targetScrapeCacheFlushForced semconv.PrometheusTargetScrapesCacheFlushForcedTotal
 
 	// Used by scrapeLoop.
-	targetIntervalLength                   *prometheus.SummaryVec
-	targetIntervalLengthHistogram          *prometheus.HistogramVec
-	targetScrapeSampleLimit                prometheus.Counter
-	targetScrapeSampleDuplicate            prometheus.Counter
-	targetScrapeSampleOutOfOrder           prometheus.Counter
-	targetScrapeSampleOutOfBounds          prometheus.Counter
-	targetScrapeExemplarOutOfOrder         prometheus.Counter
-	targetScrapePoolExceededLabelLimits    prometheus.Counter
-	targetScrapeNativeHistogramBucketLimit prometheus.Counter
-	targetScrapeDuration                   prometheus.Histogram
+	targetIntervalLength                   semconv.PrometheusTargetIntervalLengthSeconds
+	targetIntervalLengthHistogram          semconv.PrometheusTargetIntervalLengthHistogramSeconds
+	targetScrapeSampleLimit                semconv.PrometheusTargetScrapesExceededSampleLimitTotal
+	targetScrapeSampleDuplicate            semconv.PrometheusTargetScrapesSampleDuplicateTimestampTotal
+	targetScrapeSampleOutOfOrder           semconv.PrometheusTargetScrapesSampleOutOfOrderTotal
+	targetScrapeSampleOutOfBounds          semconv.PrometheusTargetScrapesSampleOutOfBoundsTotal
+	targetScrapeExemplarOutOfOrder         semconv.PrometheusTargetScrapesExemplarOutOfOrderTotal
+	targetScrapePoolExceededLabelLimits    semconv.PrometheusTargetScrapePoolExceededLabelLimitsTotal
+	targetScrapeNativeHistogramBucketLimit semconv.PrometheusTargetScrapesExceededNativeHistogramBucketLimitTotal
+	targetScrapeDuration                   semconv.PrometheusTargetScrapeDurationSeconds
 }
 
 func newScrapeMetrics(reg prometheus.Registerer) (*scrapeMetrics, error) {
-	sm := &scrapeMetrics{reg: reg}
+	sm := &scrapeMetrics{
+		reg: reg,
+		// Manager metrics - MetadataMetricsCollector uses custom collector pattern (cannot migrate)
+		targetMetadataCache: &MetadataMetricsCollector{
+			CacheEntries: prometheus.NewDesc(
+				"prometheus_target_metadata_cache_entries",
+				"Total number of metric metadata entries in the cache",
+				[]string{"scrape_job"},
+				nil,
+			),
+			CacheBytes: prometheus.NewDesc(
+				"prometheus_target_metadata_cache_bytes",
+				"The number of bytes that are currently used for storing metric metadata in the cache",
+				[]string{"scrape_job"},
+				nil,
+			),
+			// TargetsGatherer should be set later, because it's a circular dependency.
+			// newScrapeMetrics() is called by NewManager(), while also TargetsGatherer is the new Manager.
+		},
+		targetScrapePools:       semconv.NewPrometheusTargetScrapePoolsTotal(),
+		targetScrapePoolsFailed: semconv.NewPrometheusTargetScrapePoolsFailedTotal(),
 
-	// Manager metrics.
-	sm.targetMetadataCache = &MetadataMetricsCollector{
-		CacheEntries: prometheus.NewDesc(
-			"prometheus_target_metadata_cache_entries",
-			"Total number of metric metadata entries in the cache",
-			[]string{"scrape_job"},
-			nil,
-		),
-		CacheBytes: prometheus.NewDesc(
-			"prometheus_target_metadata_cache_bytes",
-			"The number of bytes that are currently used for storing metric metadata in the cache",
-			[]string{"scrape_job"},
-			nil,
-		),
-		// TargetsGatherer should be set later, because it's a circular dependency.
-		// newScrapeMetrics() is called by NewManager(), while also TargetsGatherer is the new Manager.
+		// Used by scrapePool.
+		targetReloadIntervalLength:          semconv.NewPrometheusTargetReloadLengthSeconds(),
+		targetScrapePoolReloads:             semconv.NewPrometheusTargetScrapePoolReloadsTotal(),
+		targetScrapePoolReloadsFailed:       semconv.NewPrometheusTargetScrapePoolReloadsFailedTotal(),
+		targetScrapePoolExceededTargetLimit: semconv.NewPrometheusTargetScrapePoolExceededTargetLimitTotal(),
+		targetScrapePoolTargetLimit:         semconv.NewPrometheusTargetScrapePoolTargetLimit(),
+		targetScrapePoolTargetsAdded:        semconv.NewPrometheusTargetScrapePoolTargets(),
+		targetScrapePoolSymbolTableItems:    semconv.NewPrometheusTargetScrapePoolSymboltableItems(),
+		targetScrapePoolSyncsCounter:        semconv.NewPrometheusTargetScrapePoolSyncTotal(),
+		targetSyncIntervalLength:            semconv.NewPrometheusTargetSyncLengthSeconds(),
+		targetSyncIntervalLengthHistogram:   semconv.NewPrometheusTargetSyncLengthHistogramSeconds(),
+		targetSyncFailed:                    semconv.NewPrometheusTargetSyncFailedTotal(),
+
+		// Used by targetScraper.
+		targetScrapeExceededBodySizeLimit: semconv.NewPrometheusTargetScrapesExceededBodySizeLimitTotal(),
+
+		// Used by scrapeCache.
+		targetScrapeCacheFlushForced: semconv.NewPrometheusTargetScrapesCacheFlushForcedTotal(),
+
+		// Used by scrapeLoop.
+		targetIntervalLength:                   semconv.NewPrometheusTargetIntervalLengthSeconds(),
+		targetIntervalLengthHistogram:          semconv.NewPrometheusTargetIntervalLengthHistogramSeconds(),
+		targetScrapeSampleLimit:                semconv.NewPrometheusTargetScrapesExceededSampleLimitTotal(),
+		targetScrapeSampleDuplicate:            semconv.NewPrometheusTargetScrapesSampleDuplicateTimestampTotal(),
+		targetScrapeSampleOutOfOrder:           semconv.NewPrometheusTargetScrapesSampleOutOfOrderTotal(),
+		targetScrapeSampleOutOfBounds:          semconv.NewPrometheusTargetScrapesSampleOutOfBoundsTotal(),
+		targetScrapeExemplarOutOfOrder:         semconv.NewPrometheusTargetScrapesExemplarOutOfOrderTotal(),
+		targetScrapePoolExceededLabelLimits:    semconv.NewPrometheusTargetScrapePoolExceededLabelLimitsTotal(),
+		targetScrapeNativeHistogramBucketLimit: semconv.NewPrometheusTargetScrapesExceededNativeHistogramBucketLimitTotal(),
+		targetScrapeDuration:                   semconv.NewPrometheusTargetScrapeDurationSeconds(),
 	}
 
-	sm.targetScrapePools = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pools_total",
-			Help: "Total number of scrape pool creation attempts.",
-		},
-	)
-	sm.targetScrapePoolsFailed = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pools_failed_total",
-			Help: "Total number of scrape pool creations that failed.",
-		},
-	)
-
-	// Used by scrapePool.
-	sm.targetReloadIntervalLength = prometheus.NewSummaryVec(
-		prometheus.SummaryOpts{
-			Name:       "prometheus_target_reload_length_seconds",
-			Help:       "Actual interval to reload the scrape pool with a given configuration.",
-			Objectives: map[float64]float64{0.01: 0.001, 0.05: 0.005, 0.5: 0.05, 0.90: 0.01, 0.99: 0.001},
-		},
-		[]string{"interval"},
-	)
-	sm.targetScrapePoolReloads = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pool_reloads_total",
-			Help: "Total number of scrape pool reloads.",
-		},
-	)
-	sm.targetScrapePoolReloadsFailed = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pool_reloads_failed_total",
-			Help: "Total number of failed scrape pool reloads.",
-		},
-	)
-	sm.targetScrapePoolExceededTargetLimit = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pool_exceeded_target_limit_total",
-			Help: "Total number of times scrape pools hit the target limit, during sync or config reload.",
-		},
-	)
-	sm.targetScrapePoolTargetLimit = prometheus.NewGaugeVec(
-		prometheus.GaugeOpts{
-			Name: "prometheus_target_scrape_pool_target_limit",
-			Help: "Maximum number of targets allowed in this scrape pool.",
-		},
-		[]string{"scrape_job"},
-	)
-	sm.targetScrapePoolTargetsAdded = prometheus.NewGaugeVec(
-		prometheus.GaugeOpts{
-			Name: "prometheus_target_scrape_pool_targets",
-			Help: "Current number of targets in this scrape pool.",
-		},
-		[]string{"scrape_job"},
-	)
-	sm.targetScrapePoolSymbolTableItems = prometheus.NewGaugeVec(
-		prometheus.GaugeOpts{
-			Name: "prometheus_target_scrape_pool_symboltable_items",
-			Help: "Current number of symbols in table for this scrape pool.",
-		},
-		[]string{"scrape_job"},
-	)
-	sm.targetScrapePoolSyncsCounter = prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pool_sync_total",
-			Help: "Total number of syncs that were executed on a scrape pool.",
-		},
-		[]string{"scrape_job"},
-	)
-	sm.targetSyncIntervalLength = prometheus.NewSummaryVec(
-		prometheus.SummaryOpts{
-			Name:       "prometheus_target_sync_length_seconds",
-			Help:       "Actual interval to sync the scrape pool.",
-			Objectives: map[float64]float64{0.01: 0.001, 0.05: 0.005, 0.5: 0.05, 0.90: 0.01, 0.99: 0.001},
-		},
-		[]string{"scrape_job"},
-	)
-	sm.targetSyncIntervalLengthHistogram = prometheus.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Name:                            "prometheus_target_sync_length_histogram_seconds",
-			Help:                            "Actual interval to sync the scrape pool.",
-			Buckets:                         []float64{.01, .1, 1, 10},
-			NativeHistogramBucketFactor:     1.1,
-			NativeHistogramMaxBucketNumber:  100,
-			NativeHistogramMinResetDuration: 1 * time.Hour,
-		},
-		[]string{"scrape_job"},
-	)
-	sm.targetSyncFailed = prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_sync_failed_total",
-			Help: "Total number of target sync failures.",
-		},
-		[]string{"scrape_job"},
-	)
-
-	// Used by targetScraper.
-	sm.targetScrapeExceededBodySizeLimit = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_exceeded_body_size_limit_total",
-			Help: "Total number of scrapes that hit the body size limit",
-		},
-	)
-
-	// Used by scrapeCache.
-	sm.targetScrapeCacheFlushForced = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_cache_flush_forced_total",
-			Help: "How many times a scrape cache was flushed due to getting big while scrapes are failing.",
-		},
-	)
-
-	// Used by scrapeLoop.
-	sm.targetIntervalLength = prometheus.NewSummaryVec(
-		prometheus.SummaryOpts{
-			Name:       "prometheus_target_interval_length_seconds",
-			Help:       "Actual intervals between scrapes.",
-			Objectives: map[float64]float64{0.01: 0.001, 0.05: 0.005, 0.5: 0.05, 0.90: 0.01, 0.99: 0.001},
-		},
-		[]string{"interval"},
-	)
-	sm.targetIntervalLengthHistogram = prometheus.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Name:                            "prometheus_target_interval_length_histogram_seconds",
-			Help:                            "Actual intervals between scrapes.",
-			Buckets:                         []float64{.01, .1, 1, 10},
-			NativeHistogramBucketFactor:     1.1,
-			NativeHistogramMaxBucketNumber:  100,
-			NativeHistogramMinResetDuration: 1 * time.Hour,
-		},
-		[]string{"interval"},
-	)
-	sm.targetScrapeSampleLimit = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_exceeded_sample_limit_total",
-			Help: "Total number of scrapes that hit the sample limit and were rejected.",
-		},
-	)
-	sm.targetScrapeSampleDuplicate = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_sample_duplicate_timestamp_total",
-			Help: "Total number of samples rejected due to duplicate timestamps but different values.",
-		},
-	)
-	sm.targetScrapeSampleOutOfOrder = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_sample_out_of_order_total",
-			Help: "Total number of samples rejected due to not being out of the expected order.",
-		},
-	)
-	sm.targetScrapeSampleOutOfBounds = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_sample_out_of_bounds_total",
-			Help: "Total number of samples rejected due to timestamp falling outside of the time bounds.",
-		},
-	)
-	sm.targetScrapePoolExceededLabelLimits = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrape_pool_exceeded_label_limits_total",
-			Help: "Total number of times scrape pools hit the label limits, during sync or config reload.",
-		},
-	)
-	sm.targetScrapeNativeHistogramBucketLimit = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_exceeded_native_histogram_bucket_limit_total",
-			Help: "Total number of scrapes that hit the native histogram bucket limit and were rejected.",
-		},
-	)
-	sm.targetScrapeExemplarOutOfOrder = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Name: "prometheus_target_scrapes_exemplar_out_of_order_total",
-			Help: "Total number of exemplar rejected due to not being out of the expected order.",
-		},
-	)
-	sm.targetScrapeDuration = prometheus.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:                            "prometheus_target_scrape_duration_seconds",
-			Help:                            "Total duration of the scrape from start to commit completion in seconds.",
-			NativeHistogramBucketFactor:     1.1,
-			NativeHistogramMaxBucketNumber:  100,
-			NativeHistogramMinResetDuration: 1 * time.Hour,
-		},
-	)
-
 	for _, collector := range []prometheus.Collector{
 		// Used by Manager.
 		sm.targetMetadataCache,
-		sm.targetScrapePools,
-		sm.targetScrapePoolsFailed,
+		sm.targetScrapePools.Counter,
+		sm.targetScrapePoolsFailed.Counter,
 		// Used by scrapePool.
-		sm.targetReloadIntervalLength,
-		sm.targetScrapePoolReloads,
-		sm.targetScrapePoolReloadsFailed,
-		sm.targetSyncIntervalLength,
-		sm.targetSyncIntervalLengthHistogram,
-		sm.targetScrapePoolSyncsCounter,
-		sm.targetScrapePoolExceededTargetLimit,
-		sm.targetScrapePoolTargetLimit,
-		sm.targetScrapePoolTargetsAdded,
-		sm.targetScrapePoolSymbolTableItems,
-		sm.targetSyncFailed,
+		sm.targetReloadIntervalLength.SummaryVec,
+		sm.targetScrapePoolReloads.Counter,
+		sm.targetScrapePoolReloadsFailed.Counter,
+		sm.targetSyncIntervalLength.SummaryVec,
+		sm.targetSyncIntervalLengthHistogram.HistogramVec,
+		sm.targetScrapePoolSyncsCounter.CounterVec,
+		sm.targetScrapePoolExceededTargetLimit.Counter,
+		sm.targetScrapePoolTargetLimit.GaugeVec,
+		sm.targetScrapePoolTargetsAdded.GaugeVec,
+		sm.targetScrapePoolSymbolTableItems.GaugeVec,
+		sm.targetSyncFailed.CounterVec,
 		// Used by targetScraper.
-		sm.targetScrapeExceededBodySizeLimit,
+		sm.targetScrapeExceededBodySizeLimit.Counter,
 		// Used by scrapeCache.
-		sm.targetScrapeCacheFlushForced,
+		sm.targetScrapeCacheFlushForced.Counter,
 		// Used by scrapeLoop.
-		sm.targetIntervalLength,
-		sm.targetIntervalLengthHistogram,
-		sm.targetScrapeSampleLimit,
-		sm.targetScrapeSampleDuplicate,
-		sm.targetScrapeSampleOutOfOrder,
-		sm.targetScrapeSampleOutOfBounds,
-		sm.targetScrapeExemplarOutOfOrder,
-		sm.targetScrapePoolExceededLabelLimits,
-		sm.targetScrapeNativeHistogramBucketLimit,
-		sm.targetScrapeDuration,
+		sm.targetIntervalLength.SummaryVec,
+		sm.targetIntervalLengthHistogram.HistogramVec,
+		sm.targetScrapeSampleLimit.Counter,
+		sm.targetScrapeSampleDuplicate.Counter,
+		sm.targetScrapeSampleOutOfOrder.Counter,
+		sm.targetScrapeSampleOutOfBounds.Counter,
+		sm.targetScrapeExemplarOutOfOrder.Counter,
+		sm.targetScrapePoolExceededLabelLimits.Counter,
+		sm.targetScrapeNativeHistogramBucketLimit.Counter,
+		sm.targetScrapeDuration.Histogram,
 	} {
 		err := reg.Register(collector)
 		if err != nil {
@@ -311,31 +163,31 @@ func (sm *scrapeMetrics) setTargetMetadataCacheGatherer(gatherer TargetsGatherer
 // Unregister unregisters all metrics.
 func (sm *scrapeMetrics) Unregister() {
 	sm.reg.Unregister(sm.targetMetadataCache)
-	sm.reg.Unregister(sm.targetScrapePools)
-	sm.reg.Unregister(sm.targetScrapePoolsFailed)
-	sm.reg.Unregister(sm.targetReloadIntervalLength)
-	sm.reg.Unregister(sm.targetScrapePoolReloads)
-	sm.reg.Unregister(sm.targetScrapePoolReloadsFailed)
-	sm.reg.Unregister(sm.targetSyncIntervalLength)
-	sm.reg.Unregister(sm.targetSyncIntervalLengthHistogram)
-	sm.reg.Unregister(sm.targetScrapePoolSyncsCounter)
-	sm.reg.Unregister(sm.targetScrapePoolExceededTargetLimit)
-	sm.reg.Unregister(sm.targetScrapePoolTargetLimit)
-	sm.reg.Unregister(sm.targetScrapePoolTargetsAdded)
-	sm.reg.Unregister(sm.targetScrapePoolSymbolTableItems)
-	sm.reg.Unregister(sm.targetSyncFailed)
-	sm.reg.Unregister(sm.targetScrapeExceededBodySizeLimit)
-	sm.reg.Unregister(sm.targetScrapeCacheFlushForced)
-	sm.reg.Unregister(sm.targetIntervalLength)
-	sm.reg.Unregister(sm.targetIntervalLengthHistogram)
-	sm.reg.Unregister(sm.targetScrapeSampleLimit)
-	sm.reg.Unregister(sm.targetScrapeSampleDuplicate)
-	sm.reg.Unregister(sm.targetScrapeSampleOutOfOrder)
-	sm.reg.Unregister(sm.targetScrapeSampleOutOfBounds)
-	sm.reg.Unregister(sm.targetScrapeExemplarOutOfOrder)
-	sm.reg.Unregister(sm.targetScrapePoolExceededLabelLimits)
-	sm.reg.Unregister(sm.targetScrapeNativeHistogramBucketLimit)
-	sm.reg.Unregister(sm.targetScrapeDuration)
+	sm.reg.Unregister(sm.targetScrapePools.Counter)
+	sm.reg.Unregister(sm.targetScrapePoolsFailed.Counter)
+	sm.reg.Unregister(sm.targetReloadIntervalLength.SummaryVec)
+	sm.reg.Unregister(sm.targetScrapePoolReloads.Counter)
+	sm.reg.Unregister(sm.targetScrapePoolReloadsFailed.Counter)
+	sm.reg.Unregister(sm.targetSyncIntervalLength.SummaryVec)
+	sm.reg.Unregister(sm.targetSyncIntervalLengthHistogram.HistogramVec)
+	sm.reg.Unregister(sm.targetScrapePoolSyncsCounter.CounterVec)
+	sm.reg.Unregister(sm.targetScrapePoolExceededTargetLimit.Counter)
+	sm.reg.Unregister(sm.targetScrapePoolTargetLimit.GaugeVec)
+	sm.reg.Unregister(sm.targetScrapePoolTargetsAdded.GaugeVec)
+	sm.reg.Unregister(sm.targetScrapePoolSymbolTableItems.GaugeVec)
+	sm.reg.Unregister(sm.targetSyncFailed.CounterVec)
+	sm.reg.Unregister(sm.targetScrapeExceededBodySizeLimit.Counter)
+	sm.reg.Unregister(sm.targetScrapeCacheFlushForced.Counter)
+	sm.reg.Unregister(sm.targetIntervalLength.SummaryVec)
+	sm.reg.Unregister(sm.targetIntervalLengthHistogram.HistogramVec)
+	sm.reg.Unregister(sm.targetScrapeSampleLimit.Counter)
+	sm.reg.Unregister(sm.targetScrapeSampleDuplicate.Counter)
+	sm.reg.Unregister(sm.targetScrapeSampleOutOfOrder.Counter)
+	sm.reg.Unregister(sm.targetScrapeSampleOutOfBounds.Counter)
+	sm.reg.Unregister(sm.targetScrapeExemplarOutOfOrder.Counter)
+	sm.reg.Unregister(sm.targetScrapePoolExceededLabelLimits.Counter)
+	sm.reg.Unregister(sm.targetScrapeNativeHistogramBucketLimit.Counter)
+	sm.reg.Unregister(sm.targetScrapeDuration.Histogram)
 }
 
 type TargetsGatherer interface {

scrape/semconv/README.md

@@ -10,6 +10,7 @@ This document describes the metrics defined in this semantic convention registry
 | `prometheus_target_interval_length_seconds` | histogram | s | Actual intervals between scrapes. |
 | `prometheus_target_metadata_cache_bytes` | gauge | By | The number of bytes that are currently used for storing metric metadata in the cache. |
 | `prometheus_target_metadata_cache_entries` | gauge | {entry} | Total number of metric metadata entries in the cache. |
+| `prometheus_target_reload_length_seconds` | histogram | s | Actual interval to reload the scrape pool with a given configuration. |
 | `prometheus_target_scrape_duration_seconds` | histogram | s | Scrape request latency histogram. |
 | `prometheus_target_scrape_pool_exceeded_label_limits_total` | counter | {occurrence} | Total number of times scrape pools hit the label limits. |
 | `prometheus_target_scrape_pool_exceeded_target_limit_total` | counter | {occurrence} | Total number of times scrape pools hit the target limit. |
@@ -61,6 +62,13 @@ Actual intervals between scrapes.
 - **Unit:** s
 - **Stability:** development
 
+#### Attributes
+
+| Attribute | Type | Description | Examples |
+|-----------|------|-------------|----------|
+| `interval` | string | The configured scrape interval. | 15s, 30s |
+
+
 
 ### `prometheus_target_metadata_cache_bytes`
 
@@ -94,6 +102,22 @@ Total number of metric metadata entries in the cache.
 
 
 
+### `prometheus_target_reload_length_seconds`
+
+Actual interval to reload the scrape pool with a given configuration.
+
+- **Type:** histogram
+- **Unit:** s
+- **Stability:** development
+
+#### Attributes
+
+| Attribute | Type | Description | Examples |
+|-----------|------|-------------|----------|
+| `interval` | string | The configured scrape interval. | 15s, 30s |
+
+
+
 ### `prometheus_target_scrape_duration_seconds`
 
 Scrape request latency histogram.
@@ -332,3 +356,10 @@ Actual interval to sync the scrape pool.
 - **Type:** histogram
 - **Unit:** s
 - **Stability:** development
+
+#### Attributes
+
+| Attribute | Type | Description | Examples |
+|-----------|------|-------------|----------|
+| `scrape_job` | string | The scrape job name. | prometheus, node_exporter |
+

scrape/semconv/metrics.go

@@ -5,6 +5,8 @@
 package metrics
 
 import (
+	"time"
+
 	"github.com/prometheus/client_golang/prometheus"
 )
 
@@ -45,8 +47,12 @@ func NewPrometheusTargetIntervalLengthHistogramSeconds() PrometheusTargetInterva
 	}
 	return PrometheusTargetIntervalLengthHistogramSeconds{
 		HistogramVec: prometheus.NewHistogramVec(prometheus.HistogramOpts{
-			Name: "prometheus_target_interval_length_histogram_seconds",
-			Help: "Actual intervals between scrapes as a histogram.",
+			Name:                            "prometheus_target_interval_length_histogram_seconds",
+			Help:                            "Actual intervals between scrapes as a histogram.",
+			Buckets:                         []float64{0.01, 0.1, 1, 10},
+			NativeHistogramBucketFactor:     1.1,
+			NativeHistogramMaxBucketNumber:  100,
+			NativeHistogramMinResetDuration: 1 * time.Hour,
 		}, labels),
 	}
 }
@@ -72,19 +78,48 @@ func (m PrometheusTargetIntervalLengthHistogramSeconds) With(
 
 // PrometheusTargetIntervalLengthSeconds records the actual intervals between scrapes.
 type PrometheusTargetIntervalLengthSeconds struct {
-	prometheus.Histogram
+	*prometheus.SummaryVec
 }
 
 // NewPrometheusTargetIntervalLengthSeconds returns a new PrometheusTargetIntervalLengthSeconds instrument.
 func NewPrometheusTargetIntervalLengthSeconds() PrometheusTargetIntervalLengthSeconds {
+	labels := []string{
+		"interval",
+	}
 	return PrometheusTargetIntervalLengthSeconds{
-		Histogram: prometheus.NewHistogram(prometheus.HistogramOpts{
+		SummaryVec: prometheus.NewSummaryVec(prometheus.SummaryOpts{
 			Name: "prometheus_target_interval_length_seconds",
 			Help: "Actual intervals between scrapes.",
-		}),
+			Objectives: map[float64]float64{
+				0.01: 0.001,
+				0.05: 0.005,
+				0.5:  0.05,
+				0.9:  0.01,
+				0.99: 0.001,
+			},
+		}, labels),
 	}
 }
 
+type PrometheusTargetIntervalLengthSecondsAttr interface {
+	Attribute
+	implPrometheusTargetIntervalLengthSeconds()
+}
+
+func (a IntervalAttr) implPrometheusTargetIntervalLengthSeconds() {}
+
+func (m PrometheusTargetIntervalLengthSeconds) With(
+	extra ...PrometheusTargetIntervalLengthSecondsAttr,
+) prometheus.Observer {
+	labels := prometheus.Labels{
+		"interval": "",
+	}
+	for _, v := range extra {
+		labels[v.ID()] = v.Value()
+	}
+	return m.SummaryVec.With(labels)
+}
+
 // PrometheusTargetMetadataCacheBytes records the number of bytes that are currently used for storing metric metadata in the cache.
 type PrometheusTargetMetadataCacheBytes struct {
 	*prometheus.GaugeVec
@@ -159,6 +194,50 @@ func (m PrometheusTargetMetadataCacheEntries) With(
 	return m.GaugeVec.With(labels)
 }
 
+// PrometheusTargetReloadLengthSeconds records the actual interval to reload the scrape pool with a given configuration.
+type PrometheusTargetReloadLengthSeconds struct {
+	*prometheus.SummaryVec
+}
+
+// NewPrometheusTargetReloadLengthSeconds returns a new PrometheusTargetReloadLengthSeconds instrument.
+func NewPrometheusTargetReloadLengthSeconds() PrometheusTargetReloadLengthSeconds {
+	labels := []string{
+		"interval",
+	}
+	return PrometheusTargetReloadLengthSeconds{
+		SummaryVec: prometheus.NewSummaryVec(prometheus.SummaryOpts{
+			Name: "prometheus_target_reload_length_seconds",
+			Help: "Actual interval to reload the scrape pool with a given configuration.",
+			Objectives: map[float64]float64{
+				0.01: 0.001,
+				0.05: 0.005,
+				0.5:  0.05,
+				0.9:  0.01,
+				0.99: 0.001,
+			},
+		}, labels),
+	}
+}
+
+type PrometheusTargetReloadLengthSecondsAttr interface {
+	Attribute
+	implPrometheusTargetReloadLengthSeconds()
+}
+
+func (a IntervalAttr) implPrometheusTargetReloadLengthSeconds() {}
+
+func (m PrometheusTargetReloadLengthSeconds) With(
+	extra ...PrometheusTargetReloadLengthSecondsAttr,
+) prometheus.Observer {
+	labels := prometheus.Labels{
+		"interval": "",
+	}
+	for _, v := range extra {
+		labels[v.ID()] = v.Value()
+	}
+	return m.SummaryVec.With(labels)
+}
+
 // PrometheusTargetScrapeDurationSeconds records the scrape request latency histogram.
 type PrometheusTargetScrapeDurationSeconds struct {
 	prometheus.Histogram
@@ -168,8 +247,11 @@ type PrometheusTargetScrapeDurationSeconds struct {
 func NewPrometheusTargetScrapeDurationSeconds() PrometheusTargetScrapeDurationSeconds {
 	return PrometheusTargetScrapeDurationSeconds{
 		Histogram: prometheus.NewHistogram(prometheus.HistogramOpts{
-			Name: "prometheus_target_scrape_duration_seconds",
-			Help: "Scrape request latency histogram.",
+			Name:                            "prometheus_target_scrape_duration_seconds",
+			Help:                            "Scrape request latency histogram.",
+			NativeHistogramBucketFactor:     1.1,
+			NativeHistogramMaxBucketNumber:  100,
+			NativeHistogramMinResetDuration: 1 * time.Hour,
 		}),
 	}
 }
@@ -581,8 +663,12 @@ func NewPrometheusTargetSyncLengthHistogramSeconds() PrometheusTargetSyncLengthH
 	}
 	return PrometheusTargetSyncLengthHistogramSeconds{
 		HistogramVec: prometheus.NewHistogramVec(prometheus.HistogramOpts{
-			Name: "prometheus_target_sync_length_histogram_seconds",
-			Help: "Actual interval to sync the scrape pool as a histogram.",
+			Name:                            "prometheus_target_sync_length_histogram_seconds",
+			Help:                            "Actual interval to sync the scrape pool as a histogram.",
+			Buckets:                         []float64{0.01, 0.1, 1, 10},
+			NativeHistogramBucketFactor:     1.1,
+			NativeHistogramMaxBucketNumber:  100,
+			NativeHistogramMinResetDuration: 1 * time.Hour,
 		}, labels),
 	}
 }
@@ -608,15 +694,44 @@ func (m PrometheusTargetSyncLengthHistogramSeconds) With(
 
 // PrometheusTargetSyncLengthSeconds records the actual interval to sync the scrape pool.
 type PrometheusTargetSyncLengthSeconds struct {
-	prometheus.Histogram
+	*prometheus.SummaryVec
 }
 
 // NewPrometheusTargetSyncLengthSeconds returns a new PrometheusTargetSyncLengthSeconds instrument.
 func NewPrometheusTargetSyncLengthSeconds() PrometheusTargetSyncLengthSeconds {
+	labels := []string{
+		"scrape_job",
+	}
 	return PrometheusTargetSyncLengthSeconds{
-		Histogram: prometheus.NewHistogram(prometheus.HistogramOpts{
+		SummaryVec: prometheus.NewSummaryVec(prometheus.SummaryOpts{
 			Name: "prometheus_target_sync_length_seconds",
 			Help: "Actual interval to sync the scrape pool.",
-		}),
+			Objectives: map[float64]float64{
+				0.01: 0.001,
+				0.05: 0.005,
+				0.5:  0.05,
+				0.9:  0.01,
+				0.99: 0.001,
+			},
+		}, labels),
 	}
 }
+
+type PrometheusTargetSyncLengthSecondsAttr interface {
+	Attribute
+	implPrometheusTargetSyncLengthSeconds()
+}
+
+func (a ScrapeJobAttr) implPrometheusTargetSyncLengthSeconds() {}
+
+func (m PrometheusTargetSyncLengthSeconds) With(
+	extra ...PrometheusTargetSyncLengthSecondsAttr,
+) prometheus.Observer {
+	labels := prometheus.Labels{
+		"scrape_job": "",
+	}
+	for _, v := range extra {
+		labels[v.ID()] = v.Value()
+	}
+	return m.SummaryVec.With(labels)
+}

scrape/semconv/registry.yaml

@@ -11,6 +11,23 @@ groups:
     metric_name: prometheus_target_interval_length_seconds
     instrument: histogram
     unit: s
+    attributes:
+      - id: interval
+        type: string
+        stability: development
+        brief: The configured scrape interval.
+        examples:
+          - 15s
+          - 30s
+    annotations:
+      prometheus:
+        histogram_type: summary
+        objectives:
+          0.01: 0.001
+          0.05: 0.005
+          0.5: 0.05
+          0.9: 0.01
+          0.99: 0.001
 
   - id: metric.prometheus_target_interval_length_histogram_seconds
     type: metric
@@ -27,6 +44,13 @@ groups:
         examples:
           - 15s
           - 30s
+    annotations:
+      prometheus:
+        histogram_type: mixed_histogram
+        buckets: [0.01, 0.1, 1, 10]
+        bucket_factor: 1.1
+        max_bucket_number: 100
+        min_reset_duration: "1h"
 
   - id: metric.prometheus_target_metadata_cache_bytes
     type: metric
@@ -60,6 +84,31 @@ groups:
           - prometheus
           - node_exporter
 
+  - id: metric.prometheus_target_reload_length_seconds
+    type: metric
+    stability: development
+    brief: Actual interval to reload the scrape pool with a given configuration.
+    metric_name: prometheus_target_reload_length_seconds
+    instrument: histogram
+    unit: s
+    attributes:
+      - id: interval
+        type: string
+        stability: development
+        brief: The configured scrape interval.
+        examples:
+          - 15s
+          - 30s
+    annotations:
+      prometheus:
+        histogram_type: summary
+        objectives:
+          0.01: 0.001
+          0.05: 0.005
+          0.5: 0.05
+          0.9: 0.01
+          0.99: 0.001
+
   - id: metric.prometheus_target_scrape_duration_seconds
     type: metric
     stability: development
@@ -67,6 +116,12 @@ groups:
     metric_name: prometheus_target_scrape_duration_seconds
     instrument: histogram
     unit: s
+    annotations:
+      prometheus:
+        histogram_type: native_histogram
+        bucket_factor: 1.1
+        max_bucket_number: 100
+        min_reset_duration: "1h"
 
   - id: metric.prometheus_target_scrape_pool_exceeded_label_limits_total
     type: metric
@@ -267,6 +322,23 @@ groups:
     metric_name: prometheus_target_sync_length_seconds
     instrument: histogram
     unit: s
+    attributes:
+      - id: scrape_job
+        type: string
+        stability: development
+        brief: The scrape job name.
+        examples:
+          - prometheus
+          - node_exporter
+    annotations:
+      prometheus:
+        histogram_type: summary
+        objectives:
+          0.01: 0.001
+          0.05: 0.005
+          0.5: 0.05
+          0.9: 0.01
+          0.99: 0.001
 
   - id: metric.prometheus_target_sync_length_histogram_seconds
     type: metric
@@ -283,3 +355,10 @@ groups:
         examples:
           - prometheus
           - node_exporter
+    annotations:
+      prometheus:
+        histogram_type: mixed_histogram
+        buckets: [0.01, 0.1, 1, 10]
+        bucket_factor: 1.1
+        max_bucket_number: 100
+        min_reset_duration: "1h"