set a default TTL for query plans

.changesets/feat_geal_query_plan_cache_default_ttl.md

@@ -0,0 +1,5 @@
+### set a default TTL for query plans ([Issue #4473](https://github.com/apollographql/router/issues/4473))
+
+This sets a default TTL of 30 days for query plan caches, because the previous default was to store query plans indefinitely, which does not make sense because they change with schema updates.
+
+By [@Geal](https://github.com/Geal) in https://github.com/apollographql/router/pull/4588

apollo-router/src/configuration/mod.rs

@@ -890,7 +890,7 @@ impl Default for Apq {
 #[serde(deny_unknown_fields, default)]
 pub(crate) struct QueryPlanning {
     /// Cache configuration
-    pub(crate) cache: Cache,
+    pub(crate) cache: QueryPlanCache,
     /// Warms up the cache on reloads by running the query plan over
     /// a list of the most used queries (from the in memory cache)
     /// Configures the number of queries warmed up. Defaults to 1/3 of
@@ -926,6 +926,62 @@ pub(crate) struct QueryPlanning {
     pub(crate) experimental_reuse_query_plans: bool,
 }
 
+/// Cache configuration
+#[derive(Debug, Clone, Default, Deserialize, Serialize, JsonSchema)]
+#[serde(deny_unknown_fields, default)]
+pub(crate) struct QueryPlanCache {
+    /// Configures the in memory cache (always active)
+    pub(crate) in_memory: InMemoryCache,
+    /// Configures and activates the Redis cache
+    pub(crate) redis: Option<QueryPlanRedisCache>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+/// Redis cache configuration
+pub(crate) struct QueryPlanRedisCache {
+    /// List of URLs to the Redis cluster
+    pub(crate) urls: Vec<url::Url>,
+
+    /// Redis username if not provided in the URLs. This field takes precedence over the username in the URL
+    pub(crate) username: Option<String>,
+    /// Redis password if not provided in the URLs. This field takes precedence over the password in the URL
+    pub(crate) password: Option<String>,
+
+    #[serde(deserialize_with = "humantime_serde::deserialize", default)]
+    #[schemars(with = "Option<String>", default)]
+    /// Redis request timeout (default: 2ms)
+    pub(crate) timeout: Option<Duration>,
+
+    #[serde(
+        deserialize_with = "humantime_serde::deserialize",
+        default = "default_query_plan_cache_ttl"
+    )]
+    #[schemars(with = "Option<String>", default = "default_query_plan_cache_ttl")]
+    /// TTL for entries
+    pub(crate) ttl: Duration,
+
+    /// namespace used to prefix Redis keys
+    pub(crate) namespace: Option<String>,
+
+    #[serde(default)]
+    /// TLS client configuration
+    pub(crate) tls: Option<TlsClient>,
+
+    #[serde(default = "default_required_to_start")]
+    /// Prevents the router from starting if it cannot connect to Redis
+    pub(crate) required_to_start: bool,
+
+    #[serde(default = "default_reset_ttl")]
+    /// When a TTL is set on a key, reset it when reading the data from that key
+    pub(crate) reset_ttl: bool,
+}
+
+fn default_query_plan_cache_ttl() -> Duration {
+    // Default TTL set to 30 days
+    Duration::from_secs(86400 * 30)
+}
+
 /// Cache configuration
 #[derive(Debug, Clone, Default, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields, default)]
@@ -936,6 +992,15 @@ pub(crate) struct Cache {
     pub(crate) redis: Option<RedisCache>,
 }
 
+impl From<QueryPlanCache> for Cache {
+    fn from(value: QueryPlanCache) -> Self {
+        Cache {
+            in_memory: value.in_memory,
+            redis: value.redis.map(Into::into),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 /// In memory cache configuration
@@ -994,6 +1059,22 @@ fn default_required_to_start() -> bool {
     false
 }
 
+impl From<QueryPlanRedisCache> for RedisCache {
+    fn from(value: QueryPlanRedisCache) -> Self {
+        RedisCache {
+            urls: value.urls,
+            username: value.username,
+            password: value.password,
+            timeout: value.timeout,
+            ttl: Some(value.ttl),
+            namespace: value.namespace,
+            tls: value.tls,
+            required_to_start: value.required_to_start,
+            reset_ttl: value.reset_ttl,
+        }
+    }
+}
+
 fn default_reset_ttl() -> bool {
     true
 }

apollo-router/src/configuration/snapshots/apollo_router__configuration__tests__schema_generation.snap

@@ -2808,7 +2808,10 @@ expression: "&schema"
                     },
                     "ttl": {
                       "description": "TTL for entries",
-                      "default": null,
+                      "default": {
+                        "secs": 2592000,
+                        "nanos": 0
+                      },
                       "type": "string",
                       "nullable": true
                     },

apollo-router/src/query_planner/caching_query_planner.rs

@@ -83,7 +83,7 @@ where
     ) -> Result<CachingQueryPlanner<T>, BoxError> {
         let cache = Arc::new(
             DeduplicatingCache::from_configuration(
-                &configuration.supergraph.query_planning.cache,
+                &configuration.supergraph.query_planning.cache.clone().into(),
                 "query planner",
             )
             .await?,

docs/source/configuration/distributed-caching.mdx

@@ -132,7 +132,7 @@ supergraph:
         username: admin/123 # Optional, can be part of the urls directly, mainly useful if you have special character like '/' in your password that doesn't work in url. This field takes precedence over the username in the URL
         password: admin # Optional, can be part of the urls directly, mainly useful if you have special character like '/' in your password that doesn't work in url. This field takes precedence over the password in the URL
         timeout: 5ms # Optional, by default: 2ms
-        ttl: 24h # Optional, by default no expiration
+        ttl: 24h # Optional
         namespace: "prefix"  # Optional
         #tls:
         required_to_start: false # Optional, defaults to false
@@ -146,7 +146,7 @@ Connecting and sending commands to Redis are subject to a timeout, set by defaul
 
 #### TTL
 
-The `ttl` option defines the default global expiration for Redis entries.
+The `ttl` option defines the default global expiration for Redis entries. For APQ caching, the default is no expiration, while for query plan caching, the default expiration is set to 30 days.
 
 ### Namespace