diff --git a/pageserver/src/context.rs b/pageserver/src/context.rs index 04dcca4299..febef80f28 100644 --- a/pageserver/src/context.rs +++ b/pageserver/src/context.rs @@ -523,9 +523,6 @@ impl RequestContext { self.access_stats_behavior } - pub(crate) fn page_content_kind(&self) -> PageContentKind { - self.page_content_kind - } pub(crate) fn read_path_debug(&self) -> bool { self.read_path_debug diff --git a/pageserver/src/metrics.rs b/pageserver/src/metrics.rs index 8788f04779..c7d05e527e 100644 --- a/pageserver/src/metrics.rs +++ b/pageserver/src/metrics.rs @@ -27,13 +27,11 @@ use utils::id::TimelineId; use crate::config; use crate::config::PageServerConf; -use crate::context::{PageContentKind, RequestContext}; use crate::pgdatadir_mapping::DatadirModificationStats; use crate::task_mgr::TaskKind; use crate::tenant::Timeline; use crate::tenant::mgr::TenantSlot; use crate::tenant::storage_layer::{InMemoryLayer, PersistentLayerDesc}; -use crate::tenant::tasks::BackgroundLoopKind; use crate::tenant::throttle::ThrottleResult; /// Prometheus histogram buckets (in seconds) for operations in the critical @@ -194,63 +192,6 @@ pub(crate) struct ScanLatency { } -pub(crate) struct PageCacheMetricsForTaskKind { - pub read_accesses_immutable: IntCounter, - pub read_hits_immutable: IntCounter, -} - -pub(crate) struct PageCacheMetrics { - map: EnumMap>, -} - -static PAGE_CACHE_READ_HITS: Lazy = Lazy::new(|| { - register_int_counter_vec!( - "pageserver_page_cache_read_hits_total", - "Number of read accesses to the page cache that hit", - &["task_kind", "key_kind", "content_kind", "hit_kind"] - ) - .expect("failed to define a metric") -}); - -static PAGE_CACHE_READ_ACCESSES: Lazy = Lazy::new(|| { - register_int_counter_vec!( - "pageserver_page_cache_read_accesses_total", - "Number of read accesses to the page cache", - &["task_kind", "key_kind", "content_kind"] - ) - .expect("failed to define a metric") -}); - -pub(crate) static PAGE_CACHE: Lazy = Lazy::new(|| PageCacheMetrics { - map: EnumMap::from_array(std::array::from_fn(|task_kind| { - let task_kind = TaskKind::from_usize(task_kind); - let task_kind: &'static str = task_kind.into(); - EnumMap::from_array(std::array::from_fn(|content_kind| { - let content_kind = PageContentKind::from_usize(content_kind); - let content_kind: &'static str = content_kind.into(); - PageCacheMetricsForTaskKind { - read_accesses_immutable: { - PAGE_CACHE_READ_ACCESSES - .get_metric_with_label_values(&[task_kind, "immutable", content_kind]) - .unwrap() - }, - - read_hits_immutable: { - PAGE_CACHE_READ_HITS - .get_metric_with_label_values(&[task_kind, "immutable", content_kind, "-"]) - .unwrap() - }, - } - })) - })), -}); - -impl PageCacheMetrics { - pub(crate) fn for_ctx(&self, ctx: &RequestContext) -> &PageCacheMetricsForTaskKind { - &self.map[ctx.task_kind()][ctx.page_content_kind()] - } -} - pub(crate) struct PageCacheSizeMetrics { pub max_bytes: UIntGauge, @@ -1619,17 +1560,6 @@ impl BasebackupQueryTimeOngoingRecording<'_> { } } -pub(crate) static LIVE_CONNECTIONS: Lazy = Lazy::new(|| { - register_int_counter_pair_vec!( - "pageserver_live_connections_started", - "Number of network connections that we started handling", - "pageserver_live_connections_finished", - "Number of network connections that we finished handling", - &["pageserver_connection_kind"] - ) - .expect("failed to define a metric") -}); - #[derive(Clone, Copy, enum_map::Enum, IntoStaticStr)] pub(crate) enum ComputeCommandKind { PageStreamV3, @@ -1639,33 +1569,6 @@ pub(crate) enum ComputeCommandKind { LeaseLsn, } -pub(crate) struct ComputeCommandCounters { - map: EnumMap, -} - -pub(crate) static COMPUTE_COMMANDS_COUNTERS: Lazy = Lazy::new(|| { - let inner = register_int_counter_vec!( - "pageserver_compute_commands", - "Number of compute -> pageserver commands processed", - &["command"] - ) - .expect("failed to define a metric"); - - ComputeCommandCounters { - map: EnumMap::from_array(std::array::from_fn(|i| { - let command = ComputeCommandKind::from_usize(i); - let command_str: &'static str = command.into(); - inner.with_label_values(&[command_str]) - })), - } -}); - -impl ComputeCommandCounters { - pub(crate) fn for_command(&self, command: ComputeCommandKind) -> &IntCounter { - &self.map[command] - // TODO: .inc() needs to be commented out at call site - } -} // remote storage metrics @@ -1918,84 +1821,6 @@ pub(crate) static TENANT_TASK_EVENTS: Lazy = Lazy::new(|| { .expect("Failed to register tenant_task_events metric") }); -pub struct BackgroundLoopSemaphoreMetrics { - counters: EnumMap, -} - -pub(crate) static BACKGROUND_LOOP_SEMAPHORE: Lazy = - Lazy::new(|| { - let counters = register_int_counter_pair_vec!( - "pageserver_background_loop_semaphore_wait_start_count", - "Counter for background loop concurrency-limiting semaphore acquire calls started", - "pageserver_background_loop_semaphore_wait_finish_count", - "Counter for background loop concurrency-limiting semaphore acquire calls finished", - &["task"], - ) - .unwrap(); - - BackgroundLoopSemaphoreMetrics { - counters: EnumMap::from_array(std::array::from_fn(|i| { - let kind = BackgroundLoopKind::from_usize(i); - counters.with_label_values(&[kind.into()]) - })), - } - }); - -impl BackgroundLoopSemaphoreMetrics { - /// Starts recording semaphore metrics. Call `acquired()` on the returned recorder when the - /// semaphore is acquired, and drop it when the task completes or is cancelled. - pub(crate) fn record( - &self, - task: BackgroundLoopKind, - ) -> BackgroundLoopSemaphoreMetricsRecorder { - BackgroundLoopSemaphoreMetricsRecorder::start(self, task) - } -} - -/// Records metrics for a background task. -pub struct BackgroundLoopSemaphoreMetricsRecorder { - - start: Instant, - wait_counter_guard: Option, -} - -impl<'a> BackgroundLoopSemaphoreMetricsRecorder { - /// Starts recording semaphore metrics, by recording wait time and incrementing - /// `wait_start_count` and `waiting_tasks`. - fn start(metrics: &'a BackgroundLoopSemaphoreMetrics, task: BackgroundLoopKind) -> Self { - // metrics.waiting_tasks[task].inc(); - Self { - - start: Instant::now(), - wait_counter_guard: Some(metrics.counters[task].guard()), - } - } - - /// Signals that the semaphore has been acquired, and updates relevant metrics. - pub fn acquired(&mut self) -> Duration { - let waited = self.start.elapsed(); - self.wait_counter_guard.take().expect("already acquired"); - // self.metrics.durations[self.task].observe(waited.as_secs_f64()); - // self.metrics.waiting_tasks[self.task].dec(); - // self.metrics.running_tasks[self.task].inc(); - waited - } -} - -impl Drop for BackgroundLoopSemaphoreMetricsRecorder { - /// The task either completed or was cancelled. - fn drop(&mut self) { - if self.wait_counter_guard.take().is_some() { - // Waiting. - // self.metrics.durations[self.task].observe(self.start.elapsed().as_secs_f64()); - // self.metrics.waiting_tasks[self.task].dec(); - } else { - // Running. - // self.metrics.running_tasks[self.task].dec(); - } - } -} - pub(crate) static BACKGROUND_LOOP_PERIOD_OVERRUN_COUNT: Lazy = Lazy::new(|| { register_int_counter_vec!( "pageserver_background_loop_period_overrun_count", @@ -3486,7 +3311,6 @@ pub fn preinitialize_metrics( // Custom Lazy::force(&BASEBACKUP_QUERY_TIME); - Lazy::force(&COMPUTE_COMMANDS_COUNTERS); Lazy::force(&tokio_epoll_uring::THREAD_LOCAL_METRICS_STORAGE); tenant_throttling::preinitialize_global_metrics(); diff --git a/pageserver/src/page_cache.rs b/pageserver/src/page_cache.rs index 638a2fa254..6f32484bc9 100644 --- a/pageserver/src/page_cache.rs +++ b/pageserver/src/page_cache.rs @@ -414,32 +414,17 @@ impl PageCache { async fn lock_for_read( &self, cache_key: &CacheKey, - ctx: &RequestContext, + _ctx: &RequestContext, ) -> anyhow::Result { let mut permit = Some(self.try_get_pinned_slot_permit().await?); - let (read_access, hit) = match cache_key { - CacheKey::ImmutableFilePage { .. } => ( - &crate::metrics::PAGE_CACHE - .for_ctx(ctx) - .read_accesses_immutable, - &crate::metrics::PAGE_CACHE.for_ctx(ctx).read_hits_immutable, - ), - }; - read_access.inc(); - - let mut is_first_iteration = true; loop { // First check if the key already exists in the cache. if let Some(read_guard) = self.try_lock_for_read(cache_key, &mut permit).await { debug_assert!(permit.is_none()); - if is_first_iteration { - hit.inc(); - } return Ok(ReadBufResult::Found(read_guard)); } debug_assert!(permit.is_some()); - is_first_iteration = false; // Not found. Find a victim buffer let (slot_idx, mut inner) = self diff --git a/pageserver/src/page_service.rs b/pageserver/src/page_service.rs index 2d2ac137b0..e6ef89575c 100644 --- a/pageserver/src/page_service.rs +++ b/pageserver/src/page_service.rs @@ -59,8 +59,7 @@ use crate::context::{ DownloadBehavior, PerfInstrumentFutureExt, RequestContext, RequestContextBuilder, }; use crate::metrics::{ - self, COMPUTE_COMMANDS_COUNTERS, ComputeCommandKind, GetPageBatchBreakReason, LIVE_CONNECTIONS, - SmgrOpTimer, TimelineMetrics, + self, GetPageBatchBreakReason, SmgrOpTimer, TimelineMetrics, }; use crate::pgdatadir_mapping::Version; use crate::span::{ @@ -275,9 +274,6 @@ async fn page_service_conn_main( cancel: CancellationToken, gate_guard: GateGuard, ) -> ConnectionHandlerResult { - let _guard = LIVE_CONNECTIONS - .with_label_values(&["page_service"]) - .guard(); socket .set_nodelay(true) @@ -2909,12 +2905,7 @@ where .record("timeline_id", field::display(timeline_id)); self.check_permission(Some(tenant_id))?; - let command_kind = match protocol_version { - PagestreamProtocolVersion::V2 => ComputeCommandKind::PageStreamV2, - PagestreamProtocolVersion::V3 => ComputeCommandKind::PageStreamV3, - }; - COMPUTE_COMMANDS_COUNTERS.for_command(command_kind).inc(); - + self.handle_pagerequests(pgb, tenant_id, timeline_id, protocol_version, ctx) .await?; } @@ -2931,9 +2922,7 @@ where self.check_permission(Some(tenant_id))?; - COMPUTE_COMMANDS_COUNTERS - .for_command(ComputeCommandKind::Basebackup) - .inc(); + let metric_recording = metrics::BASEBACKUP_QUERY_TIME.start_recording(); let res = async { self.handle_basebackup_request( @@ -2968,9 +2957,7 @@ where self.check_permission(Some(tenant_id))?; - COMPUTE_COMMANDS_COUNTERS - .for_command(ComputeCommandKind::Fullbackup) - .inc(); + // Check that the timeline exists self.handle_basebackup_request( @@ -3004,9 +2991,7 @@ where self.check_permission(Some(tenant_shard_id.tenant_id))?; - COMPUTE_COMMANDS_COUNTERS - .for_command(ComputeCommandKind::LeaseLsn) - .inc(); + match self .handle_make_lsn_lease(pgb, tenant_shard_id, timeline_id, lsn, &ctx) diff --git a/pageserver/src/tenant/tasks.rs b/pageserver/src/tenant/tasks.rs index 9b88add6c5..54d8a8b8a1 100644 --- a/pageserver/src/tenant/tasks.rs +++ b/pageserver/src/tenant/tasks.rs @@ -19,7 +19,7 @@ use utils::completion::Barrier; use utils::pausable_failpoint; use crate::context::{DownloadBehavior, RequestContext}; -use crate::metrics::{self, BackgroundLoopSemaphoreMetricsRecorder, TENANT_TASK_EVENTS}; +use crate::metrics::{self, TENANT_TASK_EVENTS}; use crate::task_mgr::{self, BACKGROUND_RUNTIME, TOKIO_WORKER_THREADS, TaskKind}; use crate::tenant::throttle::Stats; use crate::tenant::timeline::CompactionError; @@ -87,7 +87,6 @@ pub(crate) enum BackgroundLoopKind { pub struct BackgroundLoopSemaphorePermit { _permit: SemaphorePermit<'static>, - _recorder: BackgroundLoopSemaphoreMetricsRecorder, } /// Acquires a semaphore permit, to limit concurrent background jobs. @@ -95,7 +94,6 @@ pub(crate) async fn acquire_concurrency_permit( loop_kind: BackgroundLoopKind, _ctx: &RequestContext, ) -> BackgroundLoopSemaphorePermit { - let mut recorder = metrics::BACKGROUND_LOOP_SEMAPHORE.record(loop_kind); if loop_kind == BackgroundLoopKind::InitialLogicalSizeCalculation { pausable_failpoint!("initial-size-calculation-permit-pause"); @@ -108,11 +106,9 @@ pub(crate) async fn acquire_concurrency_permit( }; let permit = semaphore.acquire().await.expect("should never close"); - recorder.acquired(); BackgroundLoopSemaphorePermit { _permit: permit, - _recorder: recorder, } } diff --git a/pageserver/src/tenant/timeline/walreceiver/walreceiver_connection.rs b/pageserver/src/tenant/timeline/walreceiver/walreceiver_connection.rs index 52259f205b..79c44ea4e7 100644 --- a/pageserver/src/tenant/timeline/walreceiver/walreceiver_connection.rs +++ b/pageserver/src/tenant/timeline/walreceiver/walreceiver_connection.rs @@ -36,7 +36,7 @@ use wal_decoder::wire_format::FromWireFormat; use super::TaskStateUpdate; use crate::context::RequestContext; -use crate::metrics::{LIVE_CONNECTIONS, WAL_INGEST, WALRECEIVER_STARTED_CONNECTIONS}; +use crate::metrics::{WAL_INGEST, WALRECEIVER_STARTED_CONNECTIONS}; use crate::pgdatadir_mapping::DatadirModification; use crate::task_mgr::{TaskKind, WALRECEIVER_RUNTIME}; use crate::tenant::{ @@ -223,10 +223,6 @@ pub(super) async fn handle_walreceiver_connection( .instrument(tracing::info_span!("poller")), ); - let _guard = LIVE_CONNECTIONS - .with_label_values(&["wal_receiver"]) - .guard(); - let identify = identify_system(&replication_client).await?; info!("{identify:?}");