Enable generate_query_fragments by default

.changesets/feat_lrlna_enable_generate_query_fragments_by_default.md

@@ -0,0 +1,21 @@
+### Enable query fragment generation by default
+
+The router previously had `experimental_reuse_query_fragments` enabled by
+default when trying to optimize fragments before sending operations to subgraphs.
+While on occasion this algorithm can be more performant, we found that in vast
+majority of cases the query planner can be just as performant using
+`generate_query_fragments` query plan option, which also significantly reduces
+query size being sent to subgraphs. While the two options will produce correct
+responses, the queries produced internally by the query planner will differ.
+
+This change enables `generate_query_fragments` by default, while disabling
+`experimental_reuse_query_fragments`. You can change this behavior with the
+following options:
+
+```yaml
+supergraph:
+  generate_query_fragments: false
+  experimental_reuse_query_fragments: true
+```
+
+By [@lrlna](https://github.com/lrlna) in https://github.com/apollographql/router/pull/6013

apollo-router/src/configuration/mod.rs

@@ -690,7 +690,8 @@ pub(crate) struct Supergraph {
     pub(crate) reuse_query_fragments: Option<bool>,
 
     /// Enable QP generation of fragments for subgraph requests
-    /// Default: false
+    /// Default: true
+    #[serde(default = "default_generate_query_fragments")]
     pub(crate) generate_query_fragments: bool,
 
     /// Set to false to disable defer support
@@ -710,6 +711,10 @@ pub(crate) struct Supergraph {
     pub(crate) experimental_log_on_broken_pipe: bool,
 }
 
+const fn default_generate_query_fragments() -> bool {
+    true
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", untagged)]
 pub(crate) enum AvailableParallelism {

docs/source/configuration/overview.mdx

@@ -1175,18 +1175,27 @@ example:
 
 ### Fragment reuse and generation
 
-By default, the router will attempt to reuse fragments from the original query while forming subgraph requests. This behavior can be disabled by setting the option to `false`:
+By default, the router will _generate_ fragments for subgraph requests,
+extracting _inline fragments only_ into fragment definitions before sending
+queries to subgraphs. In very many cases this significantly reduces the size of
+the query sent to subgraphs, but may increase the time it takes for planning.
+Note that this option and `experimental_reuse_query_fragments` are mutually
+exclusive; if both are explicitly set to `true`, `generate_query_fragments` will
+take precedence. This behaviour can be disabled by setting the option to `false`:
 
 ```yaml
 supergraph:
-  experimental_reuse_query_fragments: false
+  generate_query_fragments: false 
 ```
 
-Alternatively, the router can be configured to _generate_ fragments for subgraph requests. When set to `true`, the router will extract _inline fragments only_ into fragment definitions before sending queries to subgraphs. This can significantly reduce the size of the query sent to subgraphs, but may increase the time it takes for planning. Note that this option and `experimental_reuse_query_fragments` are mutually exclusive; if both are explicitly set to `true`, `generate_query_fragments` will take precedence.
+Alternatively, the router can attempt to reuse fragments from the original query
+while forming subgraph requests. This often results in largers queries sent to
+subgraphs, but it may be decrease planning times. This behavior can be enabled
+by setting the option to `true`:
 
 ```yaml
 supergraph:
-  generate_query_fragments: true
+  experimental_reuse_query_fragments: true 
 ```
 
 ### Reusing configuration