Quelle  metrics.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use std::time::Instant;

/// Single sample for a Glean labeled_timing_distribution
#[derive(uniffi::Record)]
pub struct LabeledTimingSample {
    pub label: String,
    /// Time in microseconds
    pub value: u64,
}

impl LabeledTimingSample {
    fn new(label: String, value: u64) -> Self {
        Self { label, value }
    }
}

/// Ingestion metrics
///
/// These are recorded during [crate::Store::ingest] and returned to the consumer to record.
#[derive(Default, uniffi::Record)]
pub struct SuggestIngestionMetrics {
    /// Samples for the `suggest.ingestion_time` metric
    pub ingestion_times: Vec<LabeledTimingSample>,
    /// Samples for the `suggest.ingestion_download_time` metric
    pub download_times: Vec<LabeledTimingSample>,
}

impl SuggestIngestionMetrics {
    /// Wraps each iteration in `ingest` and records the time for it.
    ///
    /// Passes the closure a `&mut MetricsContext`.
    pub fn measure_ingest<F, T>(&mut self, record_type: impl Into<String>, operation: F) -> T
    where
        F: FnOnce(&mut MetricsContext) -> T,
    {
        let timer = Instant::now();
        let record_type = record_type.into();
        let mut context = MetricsContext::default();
        let result = operation(&mut context);
        let elapsed = timer.elapsed().as_micros() as u64;
        match context {
            MetricsContext::Uninstrumented => (),
            MetricsContext::Instrumented { download_time } => {
                self.ingestion_times.push(LabeledTimingSample::new(
                    record_type.clone(),
                    elapsed - download_time,
                ));
                self.download_times
                    .push(LabeledTimingSample::new(record_type, download_time));
            }
        }
        result
    }
}

/// Context for a ingestion measurement
#[derive(Default)]
pub enum MetricsContext {
    /// Default state, if this is the state at the end of `measure_ingest`, then it means no work
    /// was done and we should not record anything
    #[default]
    Uninstrumented,
    /// State after `measure_download()` is called.  We currently always download an attachment
    /// whenever we do any ingestion work, so we can use this a test for if we should record
    /// anything.
    Instrumented { download_time: u64 },
}

impl MetricsContext {
    /// Tracks download times during the ingestion
    ///
    /// We report download times as a separate metric [Self::measure_download] can be called
    /// multiple times.  [DownloadTimer] will track the total time for all calls.
    pub fn measure_download<F, T>(&mut self, operation: F) -> T
    where
        F: FnOnce() -> T,
    {
        let timer = Instant::now();
        let result = operation();
        let elasped = timer.elapsed().as_micros() as u64;
        match self {
            Self::Uninstrumented => {
                *self = Self::Instrumented {
                    download_time: elasped,
                }
            }
            Self::Instrumented { download_time } => *download_time += elasped,
        }
        result
    }
}

/// Query metrics
///
/// These are recorded during [crate::Store::query] and returned to the consumer to record.
#[derive(Default)]
pub struct SuggestQueryMetrics {
    pub times: Vec<LabeledTimingSample>,
}

impl SuggestQueryMetrics {
    pub fn measure_query<F, T>(&mut self, provider: impl Into<String>, operation: F) -> T
    where
        F: FnOnce() -> T,
    {
        let provider = provider.into();
        let timer = Instant::now();
        // Make sure the compiler doesn't reorder/inline in a way that invalidates this
        // measurement.
        let result = std::hint::black_box(operation());
        let elapsed = timer.elapsed().as_micros() as u64;
        self.times.push(LabeledTimingSample::new(provider, elapsed));
        result
    }
}