[WIP] Migrate Error Counting to Telemetry Plugin

apollo-router/src/axum_factory/listeners.rs

@@ -550,14 +550,17 @@ mod tests {
             .unwrap();
 
         let endpoint = service_fn(|req: router::Request| async move {
-            Ok::<_, BoxError>(router::Response {
-                response: http::Response::builder()
-                    .body::<crate::services::router::Body>(body::from_bytes(
-                        "this is a test".to_string(),
-                    ))
+            Ok::<_, BoxError>(
+                router::Response::http_response_builder()
+                    .response(
+                        http::Response::builder().body::<crate::services::router::Body>(
+                            body::from_bytes("this is a test".to_string()),
+                        )?,
+                    )
+                    .context(req.context)
+                    .build()
                     .unwrap(),
-                context: req.context,
-            })
+            )
         })
         .boxed();
 
@@ -591,14 +594,14 @@ mod tests {
             .build()
             .unwrap();
         let endpoint = service_fn(|req: router::Request| async move {
-            Ok::<_, BoxError>(router::Response {
-                response: http::Response::builder()
-                    .body::<crate::services::router::Body>(body::from_bytes(
-                        "this is a test".to_string(),
-                    ))
-                    .unwrap(),
-                context: req.context,
-            })
+            router::Response::http_response_builder()
+                .response(
+                    http::Response::builder().body::<crate::services::router::Body>(
+                        body::from_bytes("this is a test".to_string()),
+                    )?,
+                )
+                .context(req.context)
+                .build()
         })
         .boxed();
 

apollo-router/src/axum_factory/tests.rs

@@ -1047,7 +1047,7 @@ async fn response_failure() -> Result<(), ApolloRouterError> {
     .await;
     let (server, client) = init(router_service).await;
 
-    let response = client
+    let mut response = client
         .post(format!(
             "{}/",
             server.graphql_listen_address().as_ref().unwrap()
@@ -1066,15 +1066,17 @@ async fn response_failure() -> Result<(), ApolloRouterError> {
         .await
         .unwrap();
 
-    assert_eq!(
-        response,
-        crate::error::FetchError::SubrequestHttpError {
-            status_code: Some(200),
-            service: "Mock service".to_string(),
-            reason: "Mock error".to_string(),
-        }
-        .to_response()
-    );
+    let mut expected_response = crate::error::FetchError::SubrequestHttpError {
+        status_code: Some(200),
+        service: "Mock service".to_string(),
+        reason: "Mock error".to_string(),
+    }
+    .to_response();
+    // Overwrite error IDs to avoid random Uuid mismatch
+    response.errors[0] = response.errors[0].clone().with_null_id();
+    expected_response.errors[0] = expected_response.errors[0].clone().with_null_id();
+
+    assert_eq!(response, expected_response);
     server.shutdown().await
 }
 

apollo-router/src/context/mod.rs

@@ -29,6 +29,10 @@ pub(crate) const OPERATION_NAME: &str = "apollo::supergraph::operation_name";
 pub(crate) const OPERATION_KIND: &str = "apollo::supergraph::operation_kind";
 /// The key to know if the response body contains at least 1 GraphQL error
 pub(crate) const CONTAINS_GRAPHQL_ERROR: &str = "apollo::telemetry::contains_graphql_error";
+/// The key to a map of errors that were already counted in a previous layer
+pub(crate) const COUNTED_ERRORS: &str = "apollo::telemetry::counted_errors";
+/// The key for the full list of errors in the router response. This allows us to pull the value in plugins without having to deserialize the router response.
+pub(crate) const ROUTER_RESPONSE_ERRORS: &str = "apollo::router::response_errors";
 
 pub(crate) use deprecated::context_key_from_deprecated;
 pub(crate) use deprecated::context_key_to_deprecated;

apollo-router/src/error.rs

@@ -157,12 +157,12 @@ impl FetchError {
             }
         }
 
-        Error {
-            message: self.to_string(),
-            locations: Default::default(),
-            path,
-            extensions: value.as_object().unwrap().to_owned(),
-        }
+        Error::builder()
+            .message(self.to_string())
+            .locations(Vec::default())
+            .and_path(path)
+            .extensions(value.as_object().unwrap().to_owned())
+            .build()
     }
 
     /// Convert the error to an appropriate response.
@@ -660,6 +660,9 @@ mod tests {
             )
             .build();
 
-        assert_eq!(expected_gql_error, error.to_graphql_error(None));
+        assert_eq!(
+            expected_gql_error.with_null_id(),
+            error.to_graphql_error(None).with_null_id()
+        );
     }
 }

apollo-router/src/graphql/mod.rs

@@ -6,6 +6,7 @@ mod visitor;
 
 use std::fmt;
 use std::pin::Pin;
+use std::str::FromStr;
 
 use apollo_compiler::response::GraphQLError as CompilerExecutionError;
 use apollo_compiler::response::ResponseDataPathSegment;
@@ -20,6 +21,7 @@ use serde::Serialize;
 use serde_json_bytes::ByteString;
 use serde_json_bytes::Map as JsonMap;
 use serde_json_bytes::Value;
+use uuid::Uuid;
 pub(crate) use visitor::ResponseVisitor;
 
 use crate::json_ext::Object;
@@ -52,7 +54,7 @@ pub struct Location {
 /// as may be found in the `errors` field of a GraphQL [`Response`].
 ///
 /// Converted to (or from) JSON with serde.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Default)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[non_exhaustive]
 pub struct Error {
@@ -70,6 +72,10 @@ pub struct Error {
     /// The optional GraphQL extensions for this error.
     #[serde(default, skip_serializing_if = "Object::is_empty")]
     pub extensions: Object,
+
+    /// A unique identifier for this error
+    #[serde(default = "generate_uuid", skip_serializing)]
+    apollo_id: Uuid,
 }
 // Implement getter and getter_mut to not use pub field directly
 
@@ -103,25 +109,39 @@ impl Error {
     ///   Optional, may be called multiple times.
     ///   Adds one item to the [`Error::extensions`] map.
     ///
+    /// * `.extension_code(impl Into<`[`String`]`>)`
+    ///   Optional.
+    ///   Sets the "code" in the extension map. Will be ignored if extension already has this key
+    ///   set.
+    ///
+    /// * `.apollo_id(impl Into<`[`Uuid`]`>)`
+    ///   Optional.
+    ///   Sets the unique identifier for this Error. This should only be used in cases of
+    ///   deserialization or testing. If not given, the ID will be auto-generated.
+    ///
     /// * `.build()`
     ///   Finishes the builder and returns a GraphQL [`Error`].
     #[builder(visibility = "pub")]
-    fn new<T: Into<String>>(
+    fn new(
         message: String,
         locations: Vec<Location>,
         path: Option<Path>,
-        extension_code: T,
+        extension_code: Option<String>,
         // Skip the `Object` type alias in order to use buildstructor’s map special-casing
         mut extensions: JsonMap<ByteString, Value>,
+        apollo_id: Option<Uuid>,
     ) -> Self {
-        extensions
-            .entry("code")
-            .or_insert_with(|| extension_code.into().into());
+        if let Some(code) = extension_code {
+            extensions
+                .entry("code")
+                .or_insert(Value::String(ByteString::from(code)));
+        }
         Self {
             message,
             locations,
             path,
             extensions,
+            apollo_id: apollo_id.unwrap_or_else(Uuid::new_v4),
         }
     }
 
@@ -160,13 +180,25 @@ impl Error {
             .map_err(|err| MalformedResponseError {
                 reason: format!("invalid `path` within error: {}", err),
             })?;
-
-        Ok(Error {
-            message,
-            locations,
-            path,
-            extensions,
+        // TODO confirm camelcase key
+        let apollo_id: Option<Uuid> = extract_key_value_from_object!(
+            object,
+            "apolloId",
+            Value::String(s) => s
+        )
+        .map_err(|err| MalformedResponseError {
+            reason: format!("invalid `apolloId` within error: {}", err),
+        })?
+        .map(|s| {
+            Uuid::from_str(s.as_str()).map_err(|err| MalformedResponseError {
+                reason: format!("invalid `apolloId` within error: {}", err),
+            })
         })
+        .transpose()?;
+
+        Ok(Self::new(
+            message, locations, path, None, extensions, apollo_id,
+        ))
     }
 
     pub(crate) fn from_value_completion_value(value: &Value) -> Option<Error> {
@@ -196,13 +228,41 @@ impl Error {
                 .and_then(|p: &serde_json_bytes::Value| -> Option<Path> {
                     serde_json_bytes::from_value(p.clone()).ok()
                 });
-        Some(Error {
-            message,
-            locations,
-            path,
-            extensions,
+
+        Some(Self::new(
+            message, locations, path, None, extensions,
+            None, // apollo_id is not serialized, so it will never exist in a serialized vc error
+        ))
+    }
+
+    /// Extract the error code from [`Error::extensions`] as a String if it is set.
+    pub fn extension_code(&self) -> Option<String> {
+        self.extensions.get("code").and_then(|c| match c {
+            Value::String(s) => Some(s.as_str().to_owned()),
+            Value::Bool(b) => Some(format!("{b}")),
+            Value::Number(n) => Some(n.to_string()),
+            Value::Null | Value::Array(_) | Value::Object(_) => None,
         })
     }
+
+    /// Retrieve the internal Apollo unique ID for this error
+    pub fn apollo_id(&self) -> Uuid {
+        self.apollo_id
+    }
+
+    #[cfg(test)]
+    /// Null out the ID for comparing errors in tests where you cannot extract the randomly
+    /// generated Uuid
+    pub fn with_null_id(mut self) -> Self {
+        self.apollo_id = Uuid::nil();
+        self
+    }
+}
+
+/// Generate a random Uuid. For use in generating a default [`Error:apollo_id`] when not supplied
+/// during deserialization.
+fn generate_uuid() -> Uuid {
+    Uuid::new_v4()
 }
 
 /// GraphQL spec require that both "line" and "column" are positive numbers.
@@ -282,6 +342,7 @@ impl From<CompilerExecutionError> for Error {
             locations,
             path,
             extensions,
+            apollo_id: Uuid::new_v4(),
         }
     }
 }