graphql: no Option and noop struct

Author: kamilkisiela

graph/src/components/graphql.rs

@@ -48,9 +48,9 @@ pub trait GraphQlRunner: Send + Sync + 'static {
 }
 
 pub trait GraphQLMetrics: Send + Sync + 'static {
-    fn observe_query_execution(&self, duration: Duration, results: &QueryResults) -> ();
-    fn observe_query_parsing(&self, duration: Duration, results: &QueryResults) -> ();
-    fn observe_query_validation(&self, duration: Duration, id: &DeploymentHash) -> ();
+    fn observe_query_execution(&self, duration: Duration, results: &QueryResults);
+    fn observe_query_parsing(&self, duration: Duration, results: &QueryResults);
+    fn observe_query_validation(&self, duration: Duration, id: &DeploymentHash);
 }
 
 #[async_trait]

graphql/src/execution/query.rs

@@ -149,15 +149,13 @@ impl Query {
         query: GraphDataQuery,
         max_complexity: Option<u64>,
         max_depth: u8,
-        metrics: Option<Arc<dyn GraphQLMetrics>>,
+        metrics: Arc<dyn GraphQLMetrics>,
     ) -> Result<Arc<Self>, Vec<QueryExecutionError>> {
         let validation_phase_start = Instant::now();
         let validation_errors =
             validate(schema.document(), &query.document, &GRAPHQL_VALIDATION_PLAN);
 
-        if let Some(metrics) = metrics {
-            metrics.observe_query_validation(validation_phase_start.elapsed(), schema.id());
-        }
+        metrics.observe_query_validation(validation_phase_start.elapsed(), schema.id());
 
         if !validation_errors.is_empty() {
             if !ENV_VARS.graphql.silent_graphql_validations {

graphql/src/runner.rs

@@ -129,7 +129,7 @@ where
             query,
             max_complexity,
             max_depth,
-            Some(metrics.cheap_clone()),
+            metrics.cheap_clone(),
         )?;
         self.load_manager
             .decide(
@@ -236,7 +236,7 @@ where
             subscription.query,
             ENV_VARS.graphql.max_complexity,
             ENV_VARS.graphql.max_depth,
-            Some(self.graphql_metrics.cheap_clone()),
+            self.graphql_metrics.cheap_clone(),
         )?;
 
         if let Err(err) = self

graphql/src/subscription/mod.rs

@@ -52,7 +52,7 @@ pub fn execute_subscription(
         subscription.query,
         options.max_complexity,
         options.max_depth,
-        Some(options.graphql_metrics.cheap_clone()),
+        options.graphql_metrics.cheap_clone(),
     )?;
     execute_prepared_subscription(query, options)
 }

graphql/tests/introspection.rs

@@ -12,6 +12,7 @@ use graph_graphql::prelude::{
     a, api_schema, execute_query, ExecutionContext, Query as PreparedQuery, QueryExecutionOptions,
     Resolver,
 };
+use test_store::graphql_metrics;
 use test_store::LOAD_MANAGER;
 
 /// Mock resolver used in tests that don't need a resolver.
@@ -571,10 +572,13 @@ async fn introspection_query(schema: Schema, query: &str) -> QueryResult {
     };
 
     let schema = Arc::new(ApiSchema::from_api_schema(schema).unwrap());
-    let result = match PreparedQuery::new(&logger, schema, None, query, None, 100, None) {
-        Ok(query) => Ok(Arc::try_unwrap(execute_query(query, None, None, options).await).unwrap()),
-        Err(e) => Err(e),
-    };
+    let result =
+        match PreparedQuery::new(&logger, schema, None, query, None, 100, graphql_metrics()) {
+            Ok(query) => {
+                Ok(Arc::try_unwrap(execute_query(query, None, None, options).await).unwrap())
+            }
+            Err(e) => Err(e),
+        };
     QueryResult::from(result)
 }
 

server/http/src/service.rs

@@ -330,9 +330,9 @@ mod tests {
     }
 
     impl GraphQLMetrics for TestGraphQLMetrics {
-        fn observe_query_execution(&self, _duration: Duration, _results: &QueryResults) -> () {}
-        fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) -> () {}
-        fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) -> () {}
+        fn observe_query_execution(&self, _duration: Duration, _results: &QueryResults) {}
+        fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) {}
+        fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) {}
     }
 
     #[async_trait]

server/http/tests/server.rs

@@ -17,9 +17,9 @@ use tokio::time::sleep;
 pub struct TestGraphQLMetrics;
 
 impl GraphQLMetrics for TestGraphQLMetrics {
-    fn observe_query_execution(&self, _duration: Duration, _results: &QueryResults) -> () {}
-    fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) -> () {}
-    fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) -> () {}
+    fn observe_query_execution(&self, _duration: Duration, _results: &QueryResults) {}
+    fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) {}
+    fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) {}
 }
 
 /// A simple stupid query runner for testing.

server/index-node/src/service.rs

@@ -22,6 +22,14 @@ use crate::explorer::Explorer;
 use crate::resolver::IndexNodeResolver;
 use crate::schema::SCHEMA;
 
+struct NoopGraphQLMetrics;
+
+impl GraphQLMetrics for NoopGraphQLMetrics {
+    fn observe_query_execution(&self, _duration: Duration, _results: &QueryResults) {}
+    fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) {}
+    fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) {}
+}
+
 /// An asynchronous response to a GraphQL request.
 pub type IndexNodeServiceResponse = DynTryFuture<'static, Response<Body>, GraphQLServerError>;
 
@@ -120,7 +128,15 @@ where
         let validated = ValidatedRequest::new(body, &req_parts.headers)?;
         let query = validated.query;
 
-        let query = match PreparedQuery::new(&self.logger, schema, None, query, None, 100, None) {
+        let query = match PreparedQuery::new(
+            &self.logger,
+            schema,
+            None,
+            query,
+            None,
+            100,
+            Arc::new(NoopGraphQLMetrics),
+        ) {
             Ok(query) => query,
             Err(e) => return Ok(QueryResults::from(QueryResult::from(e)).as_http_response()),
         };

store/test-store/src/store.rs

@@ -440,7 +440,7 @@ async fn execute_subgraph_query_internal(
         query,
         max_complexity,
         100,
-        None,
+        graphql_metrics(),
     ));
     let mut result = QueryResults::empty();
     let deployment = query.schema.id().clone();