From 007469efc233eae595fa87c0555bce4837ba4a0e Mon Sep 17 00:00:00 2001 From: Arthur Silva Sens Date: Sat, 17 Jan 2026 21:07:57 -0300 Subject: [PATCH] Migrate scrape package Signed-off-by: Arthur Silva Sens --- scrape/metrics.go | 404 +++++++++++------------------------ scrape/semconv/README.md | 31 +++ scrape/semconv/metrics.go | 139 ++++++++++-- scrape/semconv/registry.yaml | 79 +++++++ 4 files changed, 365 insertions(+), 288 deletions(-) diff --git a/scrape/metrics.go b/scrape/metrics.go index 34f1e28dba..aa21be42c4 100644 --- a/scrape/metrics.go +++ b/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 { diff --git a/scrape/semconv/README.md b/scrape/semconv/README.md index e39e3d324e..e5621cdbf0 100644 --- a/scrape/semconv/README.md +++ b/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 | + diff --git a/scrape/semconv/metrics.go b/scrape/semconv/metrics.go index 11bce23688..087934ac45 100644 --- a/scrape/semconv/metrics.go +++ b/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) +} diff --git a/scrape/semconv/registry.yaml b/scrape/semconv/registry.yaml index 453cbde356..9adbf30ea8 100644 --- a/scrape/semconv/registry.yaml +++ b/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"