graph,node,docs: Improve log store configurability and error handling

Address code review feedback to improve flexibility, debuggability, docs

Author: fordN

docs/log-store.md

@@ -567,7 +567,6 @@ query {
 ```graphql
 query {
   _logs(
-    subgraphId: "QmYourSubgraphDeploymentHash"
     level: ERROR
     from: "2024-01-01T00:00:00Z"
     to: "2024-01-31T23:59:59Z"

graph/src/components/log_store/elasticsearch.rs

@@ -16,16 +16,18 @@ pub struct ElasticsearchLogStore {
     password: Option<String>,
     client: Client,
     index: String,
+    timeout: Duration,
 }
 
 impl ElasticsearchLogStore {
-    pub fn new(config: ElasticLoggingConfig, index: String) -> Self {
+    pub fn new(config: ElasticLoggingConfig, index: String, timeout: Duration) -> Self {
         Self {
             endpoint: config.endpoint,
             username: config.username,
             password: config.password,
             client: config.client,
             index,
+            timeout,
         }
     }
 
@@ -97,7 +99,7 @@ impl ElasticsearchLogStore {
             .client
             .post(&url)
             .json(&query_body)
-            .timeout(Duration::from_secs(10));
+            .timeout(self.timeout);
 
         // Add basic auth if credentials provided
         if let (Some(username), Some(password)) = (&self.username, &self.password) {
@@ -112,12 +114,17 @@ impl ElasticsearchLogStore {
 
         if !response.status().is_success() {
             let status = response.status();
-            // Do not include the response body in the error to avoid leaking
-            // sensitive Elasticsearch internals
-            return Err(LogStoreError::QueryFailed(anyhow::anyhow!(
-                "Elasticsearch query failed with status {}",
-                status
-            )));
+            // Include response body in error context for debugging
+            // The body is part of the error chain but not the main error message to avoid
+            // leaking sensitive Elasticsearch internals in logs
+            let body_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "<failed to read response body>".to_string());
+            return Err(LogStoreError::QueryFailed(
+                anyhow::anyhow!("Elasticsearch query failed with status {}", status)
+                    .context(format!("Response body: {}", body_text)),
+            ));
         }
 
         let response_body: ElasticsearchResponse = response.json().await.map_err(|e| {

graph/src/components/log_store/mod.rs

@@ -37,6 +37,7 @@ pub enum LogStoreConfig {
         username: Option<String>,
         password: Option<String>,
         index: String,
+        timeout_secs: u64,
     },
 
     /// Loki (Grafana's log aggregation system)
@@ -134,9 +135,11 @@ impl LogStoreFactory {
                 username,
                 password,
                 index,
+                timeout_secs,
             } => {
+                let timeout = std::time::Duration::from_secs(timeout_secs);
                 let client = reqwest::Client::builder()
-                    .timeout(std::time::Duration::from_secs(10))
+                    .timeout(timeout)
                     .build()
                     .map_err(|e| LogStoreError::InitializationFailed(e.into()))?;
 
@@ -148,7 +151,7 @@ impl LogStoreFactory {
                 };
 
                 Ok(Arc::new(elasticsearch::ElasticsearchLogStore::new(
-                    config, index,
+                    config, index, timeout,
                 )))
             }
 
@@ -219,11 +222,21 @@ impl LogStoreFactory {
                     "subgraph",
                 );
 
+                // Default: 10 seconds query timeout
+                // Configurable via GRAPH_LOG_STORE_ELASTICSEARCH_TIMEOUT environment variable
+                let timeout_secs = config::read_u64_with_fallback(
+                    &logger,
+                    "GRAPH_LOG_STORE_ELASTICSEARCH_TIMEOUT",
+                    "GRAPH_ELASTICSEARCH_TIMEOUT",
+                    10,
+                );
+
                 Ok(LogStoreConfig::Elasticsearch {
                     endpoint,
                     username,
                     password,
                     index,
+                    timeout_secs,
                 })
             }
 
@@ -264,13 +277,17 @@ impl LogStoreFactory {
                 })
                 .map(PathBuf::from)?;
 
+                // Default: 100MB per file (104857600 bytes)
+                // Configurable via GRAPH_LOG_STORE_FILE_MAX_SIZE environment variable
                 let max_file_size = config::read_u64_with_fallback(
                     &logger,
                     "GRAPH_LOG_STORE_FILE_MAX_SIZE",
                     "GRAPH_LOG_FILE_MAX_SIZE",
-                    100 * 1024 * 1024, // 100MB default
+                    100 * 1024 * 1024,
                 );
 
+                // Default: 30 days retention
+                // Configurable via GRAPH_LOG_STORE_FILE_RETENTION_DAYS environment variable
                 let retention_days = config::read_u32_with_fallback(
                     &logger,
                     "GRAPH_LOG_STORE_FILE_RETENTION_DAYS",

graph/src/log/factory.rs

@@ -122,6 +122,7 @@ impl LoggerFactory {
                 username,
                 password,
                 index,
+                ..
             }) => {
                 // Build ElasticLoggingConfig on-demand
                 let elastic_config = ElasticLoggingConfig {

node/src/launcher.rs

@@ -470,6 +470,12 @@ pub async fn run(
                         .or_else(|| std::env::var("GRAPH_ELASTIC_SEARCH_INDEX").ok())
                         .unwrap_or_else(|| "subgraph".to_string());
 
+                    let timeout_secs = std::env::var("GRAPH_LOG_STORE_ELASTICSEARCH_TIMEOUT")
+                        .or_else(|_| std::env::var("GRAPH_ELASTICSEARCH_TIMEOUT"))
+                        .ok()
+                        .and_then(|s| s.parse::<u64>().ok())
+                        .unwrap_or(10);
+
                     graph::components::log_store::LogStoreConfig::Elasticsearch {
                         endpoint,
                         username: opt
@@ -481,6 +487,7 @@ pub async fn run(
                             .clone()
                             .or_else(|| opt.elasticsearch_password.clone()),
                         index,
+                        timeout_secs,
                     }
                 })
             }
@@ -522,12 +529,19 @@ pub async fn run(
             .or_else(|| std::env::var("GRAPH_ELASTIC_SEARCH_INDEX").ok())
             .unwrap_or_else(|| "subgraph".to_string());
 
+        let timeout_secs = std::env::var("GRAPH_LOG_STORE_ELASTICSEARCH_TIMEOUT")
+            .or_else(|_| std::env::var("GRAPH_ELASTICSEARCH_TIMEOUT"))
+            .ok()
+            .and_then(|s| s.parse::<u64>().ok())
+            .unwrap_or(10);
+
         Some(
             graph::components::log_store::LogStoreConfig::Elasticsearch {
                 endpoint: opt.elasticsearch_url.clone().unwrap(),
                 username: opt.elasticsearch_user.clone(),
                 password: opt.elasticsearch_password.clone(),
                 index,
+                timeout_secs,
             },
         )
     } else {

node/src/log_config_provider.rs

@@ -147,6 +147,7 @@ mod tests {
             username: Some("user".to_string()),
             password: Some("pass".to_string()),
             index: "test-index".to_string(),
+            timeout_secs: 10,
         };
 
         let provider = LogStoreConfigProvider::new(LogStoreConfigSources {
@@ -161,6 +162,7 @@ mod tests {
             username,
             password,
             index,
+            ..
         }) = config
         {
             assert_eq!(endpoint, "http://localhost:9200");
@@ -182,6 +184,7 @@ mod tests {
             username: None,
             password: None,
             index: "test-index".to_string(),
+            timeout_secs: 10,
         };
 
         let provider = LogStoreConfigProvider::new(LogStoreConfigSources {