graphql: metrics for the GraphQL validation phas

Author: kamilkisiela

graphql/src/execution/query.rs

@@ -21,6 +21,7 @@ use graph::prelude::{
 
 use crate::execution::ast as a;
 use crate::query::{ast as qast, ext::BlockConstraint};
+use crate::runner::ValidationMetrics;
 use crate::schema::ast::{self as sast};
 use crate::values::coercion;
 use crate::{execution::get_field, schema::api::ErrorPolicy};
@@ -149,10 +150,14 @@ impl Query {
         query: GraphDataQuery,
         max_complexity: Option<u64>,
         max_depth: u8,
+        validation_phase: Arc<ValidationMetrics>,
     ) -> Result<Arc<Self>, Vec<QueryExecutionError>> {
+        let validation_phase_start = Instant::now();
         let validation_errors =
             validate(schema.document(), &query.document, &GRAPHQL_VALIDATION_PLAN);
 
+        validation_phase.observe(validation_phase_start.elapsed().as_nanos() as usize);
+
         if !validation_errors.is_empty() {
             if !ENV_VARS.graphql.silent_graphql_validations {
                 return Err(validation_errors

graphql/src/runner.rs

@@ -20,6 +20,52 @@ use graph::{
     prelude::QueryStore,
 };
 
+pub struct ValidationMetrics {
+    histogram: Box<Histogram>,
+    max_gauge: Box<Gauge>,
+}
+
+impl ValidationMetrics {
+    fn new(registry: Arc<dyn MetricsRegistry>) -> Self {
+        // Divide the Histogram into exponentially sized buckets between 1k and 4G
+        let bins = (10..32).map(|n| 2u64.pow(n) as f64).collect::<Vec<_>>();
+        let histogram = registry
+            .new_histogram(
+                "graphql_validation_time_ns",
+                "the time of the GraphQL validation phase (in nanoseconds)",
+                bins,
+            )
+            .unwrap();
+
+        let max_gauge = registry
+            .new_gauge(
+                "graphql_validation_max_time_ns",
+                "the maximum time of the GraphQL validation phase (in nanoseconds)",
+                HashMap::new(),
+            )
+            .unwrap();
+
+        Self {
+            histogram,
+            max_gauge,
+        }
+    }
+
+    // Tests need to construct one of these, but normal code doesn't
+    #[cfg(debug_assertions)]
+    pub fn make(registry: Arc<dyn MetricsRegistry>) -> Self {
+        Self::new(registry)
+    }
+
+    pub fn observe(&self, size: usize) {
+        let size = size as f64;
+        self.histogram.observe(size);
+        if self.max_gauge.get() < size {
+            self.max_gauge.set(size);
+        }
+    }
+}
+
 pub struct ResultSizeMetrics {
     histogram: Box<Histogram>,
     max_gauge: Box<Gauge>,
@@ -73,6 +119,7 @@ pub struct GraphQlRunner<S, SM> {
     subscription_manager: Arc<SM>,
     load_manager: Arc<LoadManager>,
     result_size: Arc<ResultSizeMetrics>,
+    validation_phase: Arc<ValidationMetrics>,
 }
 
 #[cfg(debug_assertions)]
@@ -95,13 +142,15 @@ where
         registry: Arc<dyn MetricsRegistry>,
     ) -> Self {
         let logger = logger.new(o!("component" => "GraphQlRunner"));
-        let result_size = Arc::new(ResultSizeMetrics::new(registry));
+        let result_size = Arc::new(ResultSizeMetrics::new(registry.cheap_clone()));
+        let validation_phase = Arc::new(ValidationMetrics::new(registry));
         GraphQlRunner {
             logger,
             store,
             subscription_manager,
             load_manager,
             result_size,
+            validation_phase,
         }
     }
 
@@ -144,6 +193,7 @@ where
         max_first: Option<u32>,
         max_skip: Option<u32>,
         result_size: Arc<ResultSizeMetrics>,
+        validation_phase: Arc<ValidationMetrics>,
     ) -> Result<QueryResults, QueryResults> {
         // We need to use the same `QueryStore` for the entire query to ensure
         // we have a consistent view if the world, even when replicas, which
@@ -175,6 +225,7 @@ where
             query,
             max_complexity,
             max_depth,
+            validation_phase,
         )?;
         self.load_manager
             .decide(
@@ -260,6 +311,7 @@ where
             max_first,
             max_skip,
             self.result_size.cheap_clone(),
+            self.validation_phase.cheap_clone(),
         )
         .await
         .unwrap_or_else(|e| e)
@@ -281,6 +333,7 @@ where
             subscription.query,
             ENV_VARS.graphql.max_complexity,
             ENV_VARS.graphql.max_depth,
+            self.validation_phase.cheap_clone(),
         )?;
 
         if let Err(err) = self