graphql, tests: Ensure logs graphql queries work on failed subgraphs

- include _logs in the set of special fields that bypass indexing error
shortcutting when subgraph failed
- add integration test to ensure _log queries return logs after subgraph
failed

Author: fordN

graphql/src/store/resolver.rs

@@ -13,8 +13,8 @@ use graph::derive::CheapClone;
 use graph::prelude::alloy::primitives::B256;
 use graph::prelude::*;
 use graph::schema::{
-    ast as sast, INTROSPECTION_SCHEMA_FIELD_NAME, INTROSPECTION_TYPE_FIELD_NAME, META_FIELD_NAME,
-    META_FIELD_TYPE,
+    ast as sast, INTROSPECTION_SCHEMA_FIELD_NAME, INTROSPECTION_TYPE_FIELD_NAME, LOGS_FIELD_NAME,
+    META_FIELD_NAME, META_FIELD_TYPE,
 };
 use graph::schema::{ErrorPolicy, BLOCK_FIELD_TYPE};
 
@@ -354,6 +354,23 @@ impl Resolver for StoreResolver {
             return Ok(());
         }
 
+        // Check if the query only contains debugging fields (_meta, _logs).
+        // If so, don't add indexing errors - these queries are specifically for debugging
+        // failed subgraphs and should work without errors.
+        // Introspection queries (__schema, __type) still get the indexing_error to inform
+        // users the subgraph has issues, but they return data.
+        let only_debugging_fields = result
+            .data()
+            .map(|data| {
+                data.iter()
+                    .all(|(key, _)| key == META_FIELD_NAME || key == LOGS_FIELD_NAME)
+            })
+            .unwrap_or(false);
+
+        if only_debugging_fields {
+            return Ok(());
+        }
+
         // Add the "indexing_error" to the response.
         assert!(result.errors_mut().is_empty());
         *result.errors_mut() = vec![QueryError::IndexingError];
@@ -365,9 +382,10 @@ impl Resolver for StoreResolver {
             ErrorPolicy::Deny => {
                 let mut data = result.take_data();
 
-                // Only keep the _meta, __schema and __type fields from the data
+                // Only keep the _meta, _logs, __schema and __type fields from the data
                 let meta_fields = data.as_mut().and_then(|d| {
                     let meta_field = d.remove(META_FIELD_NAME);
+                    let logs_field = d.remove(LOGS_FIELD_NAME);
                     let schema_field = d.remove(INTROSPECTION_SCHEMA_FIELD_NAME);
                     let type_field = d.remove(INTROSPECTION_TYPE_FIELD_NAME);
 
@@ -377,6 +395,9 @@ impl Resolver for StoreResolver {
                     if let Some(meta_field) = meta_field {
                         meta_fields.push((Word::from(META_FIELD_NAME), meta_field));
                     }
+                    if let Some(logs_field) = logs_field {
+                        meta_fields.push((Word::from(LOGS_FIELD_NAME), logs_field));
+                    }
                     if let Some(schema_field) = schema_field {
                         meta_fields
                             .push((Word::from(INTROSPECTION_SCHEMA_FIELD_NAME), schema_field));

tests/tests/integration_tests.rs

@@ -1136,6 +1136,71 @@ async fn test_poi_for_failed_subgraph(ctx: TestContext) -> anyhow::Result<()> {
     let resp = Subgraph::query_with_vars(FETCH_POI, vars).await?;
     assert_eq!(None, resp.get("errors"));
     assert!(resp["data"]["proofOfIndexing"].is_string());
+
+    // Test that _logs query works on failed subgraphs (critical for debugging!)
+    // Wait a moment for logs to be written
+    sleep(Duration::from_secs(2)).await;
+
+    let query = r#"{
+            _logs(first: 100) {
+                id
+                timestamp
+                level
+                text
+            }
+        }"#
+    .to_string();
+
+    let resp = subgraph.query(&query).await?;
+
+    // Should not have GraphQL errors when querying logs on failed subgraph
+    assert!(
+        resp.get("errors").is_none(),
+        "Expected no errors when querying _logs on failed subgraph, got: {:?}",
+        resp.get("errors")
+    );
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // The critical assertion: _logs query works on failed subgraphs
+    // This enables debugging even when the subgraph has crashed
+    println!(
+        "Successfully queried _logs on failed subgraph, found {} log entries",
+        logs.len()
+    );
+
+    // Print a sample of logs to see what's available (for documentation/debugging)
+    if !logs.is_empty() {
+        println!("Sample logs from failed subgraph:");
+        for (i, log) in logs.iter().take(5).enumerate() {
+            println!(
+                "  Log {}: level={:?}, text={:?}",
+                i + 1,
+                log["level"].as_str(),
+                log["text"].as_str()
+            );
+        }
+    }
+
+    // Verify we can also filter by level on failed subgraphs
+    let query = r#"{
+            _logs(level: ERROR, first: 100) {
+                level
+                text
+            }
+        }"#
+    .to_string();
+
+    let resp = subgraph.query(&query).await?;
+    assert!(
+        resp.get("errors").is_none(),
+        "Expected no errors when filtering _logs by level on failed subgraph"
+    );
+
+    println!("✓ _logs query works on failed subgraphs - critical for debugging!");
+
     Ok(())
 }