feat(plugin):router_limits plugin added

.changesets/feat_router_limits_plugin.md

@@ -0,0 +1,5 @@
+### Limiting the router by plugin for certain tiers 
+
+Beginning with how many operations are allowed over a certain interval, the router will be limited for free tier users. This adds some mild friction for using the free tier in production while allowing its capabilities to be tested.
+
+By [@aaronarinder](https://github.com/aaronarinder) in https://github.com/apollographql/router/pull/6598

apollo-router/src/axum_factory/axum_http_server_factory.rs

@@ -518,7 +518,7 @@ async fn license_handler(
 ) -> Response {
     if matches!(
         license,
-        LicenseState::LicensedHalt | LicenseState::LicensedWarn
+        LicenseState::LicensedHalt { limits: _ } | LicenseState::LicensedWarn { limits: _ }
     ) {
         // This will rate limit logs about license to 1 a second.
         // The way it works is storing the delta in seconds from a starting instant.
@@ -543,7 +543,7 @@ async fn license_handler(
         }
     }
 
-    if matches!(license, LicenseState::LicensedHalt) {
+    if matches!(license, LicenseState::LicensedHalt { limits: _ }) {
         http::Response::builder()
             .status(StatusCode::INTERNAL_SERVER_ERROR)
             .body(axum::body::Body::default())

apollo-router/src/axum_factory/utils.rs

@@ -52,7 +52,7 @@ impl<B> MakeSpan<B> for PropagatingMakeSpan {
         };
         if matches!(
             self.license,
-            LicenseState::LicensedWarn | LicenseState::LicensedHalt
+            LicenseState::LicensedWarn { limits: _ } | LicenseState::LicensedHalt { limits: _ }
         ) {
             span.record(OTEL_STATUS_CODE, OTEL_STATUS_CODE_ERROR);
             span.record("apollo_router.license", LICENSE_EXPIRED_SHORT_MESSAGE);

apollo-router/src/configuration/metrics.rs

@@ -541,6 +541,7 @@ mod test {
 
     use crate::configuration::metrics::InstrumentData;
     use crate::configuration::metrics::Metrics;
+    use crate::uplink::license_enforcement::LicenseLimits;
     use crate::uplink::license_enforcement::LicenseState;
 
     #[derive(RustEmbed)]
@@ -575,15 +576,19 @@ mod test {
     #[test]
     fn test_license_warn() {
         let mut data = InstrumentData::default();
-        data.populate_license_instrument(&LicenseState::LicensedWarn);
+        data.populate_license_instrument(&LicenseState::LicensedWarn {
+            limits: Some(LicenseLimits::default()),
+        });
         let _metrics: Metrics = data.into();
         assert_non_zero_metrics_snapshot!();
     }
 
     #[test]
     fn test_license_halt() {
         let mut data = InstrumentData::default();
-        data.populate_license_instrument(&LicenseState::LicensedHalt);
+        data.populate_license_instrument(&LicenseState::LicensedHalt {
+            limits: Some(LicenseLimits::default()),
+        });
         let _metrics: Metrics = data.into();
         assert_non_zero_metrics_snapshot!();
     }

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

@@ -5090,6 +5090,9 @@ expression: "&schema"
       },
       "type": "object"
     },
+    "RouterLimitsConfig": {
+      "type": "object"
+    },
     "RouterRequestConf": {
       "additionalProperties": false,
       "description": "What information is passed to a router request/response stage",
@@ -8735,6 +8738,10 @@ expression: "&schema"
       "$ref": "#/definitions/Conf7",
       "description": "#/definitions/Conf7"
     },
+    "router_limits": {
+      "$ref": "#/definitions/RouterLimitsConfig",
+      "description": "#/definitions/RouterLimitsConfig"
+    },
     "sandbox": {
       "$ref": "#/definitions/Sandbox",
       "description": "#/definitions/Sandbox"

apollo-router/src/metrics/mod.rs

@@ -1146,6 +1146,27 @@ macro_rules! assert_histogram_not_exists {
     };
 }
 
+/// Shared counter for `apollo.router.graphql_error` for consistency
+pub(crate) fn count_graphql_error(count: u64, code: Option<&str>) {
+    match code {
+        None => {
+            u64_counter!(
+                "apollo.router.graphql_error",
+                "Number of GraphQL error responses returned by the router",
+                count
+            );
+        }
+        Some(code) => {
+            u64_counter!(
+                "apollo.router.graphql_error",
+                "Number of GraphQL error responses returned by the router",
+                count,
+                code = code.to_string()
+            );
+        }
+    }
+}
+
 /// Assert that all metrics match an [insta] snapshot.
 ///
 /// Consider using [assert_non_zero_metrics_snapshot] to produce more grokkable snapshots if

apollo-router/src/orbiter/mod.rs

@@ -25,6 +25,7 @@ use crate::router_factory::YamlRouterFactory;
 use crate::services::router::service::RouterCreator;
 use crate::services::HasSchema;
 use crate::spec::Schema;
+use crate::uplink::license_enforcement::LicenseState;
 use crate::Configuration;
 
 /// This session id is created once when the router starts. It persists between config reloads and supergraph schema changes.
@@ -100,6 +101,7 @@ impl RouterSuperServiceFactory for OrbiterRouterSuperServiceFactory {
         schema: Arc<Schema>,
         previous_router: Option<&'a Self::RouterFactory>,
         extra_plugins: Option<Vec<(String, Box<dyn DynPlugin>)>>,
+        license: LicenseState,
     ) -> Result<Self::RouterFactory, BoxError> {
         self.delegate
             .create(
@@ -108,6 +110,7 @@ impl RouterSuperServiceFactory for OrbiterRouterSuperServiceFactory {
                 schema.clone(),
                 previous_router,
                 extra_plugins,
+                license,
             )
             .await
             .inspect(|factory| {

apollo-router/src/plugin/mod.rs

@@ -51,6 +51,7 @@ use crate::services::execution;
 use crate::services::router;
 use crate::services::subgraph;
 use crate::services::supergraph;
+use crate::uplink::license_enforcement::LicenseState;
 use crate::ListenAddr;
 
 type InstanceFactory =
@@ -81,6 +82,9 @@ pub struct PluginInit<T> {
     pub(crate) launch_id: Option<Arc<String>>,
 
     pub(crate) notify: Notify<String, graphql::Response>,
+
+    /// User's license's state, including any limits of use
+    pub(crate) license: LicenseState,
 }
 
 impl<T> PluginInit<T>
@@ -103,6 +107,7 @@ where
             .supergraph_schema(supergraph_schema)
             .launch_id(Arc::new("launch_id".to_string()))
             .notify(Notify::for_tests())
+            .license(LicenseState::default())
             .build()
     }
 }
@@ -114,6 +119,7 @@ where
 {
     /// Create a new PluginInit builder
     #[builder(entry = "builder", exit = "build", visibility = "pub")]
+    #[allow(clippy::too_many_arguments)]
     /// Build a new PluginInit for the supplied configuration and SDL.
     ///
     /// You can reuse a notify instance, or Build your own.
@@ -125,6 +131,7 @@ where
         subgraph_schemas: Option<Arc<HashMap<String, Arc<Valid<Schema>>>>>,
         launch_id: Option<Option<Arc<String>>>,
         notify: Notify<String, graphql::Response>,
+        license: LicenseState,
     ) -> Self {
         PluginInit {
             config,
@@ -134,10 +141,12 @@ where
             subgraph_schemas: subgraph_schemas.unwrap_or_default(),
             launch_id: launch_id.flatten(),
             notify,
+            license,
         }
     }
 
     #[builder(entry = "try_builder", exit = "build", visibility = "pub")]
+    #[allow(clippy::too_many_arguments)]
     /// Try to build a new PluginInit for the supplied json configuration and SDL.
     ///
     /// You can reuse a notify instance, or Build your own.
@@ -150,6 +159,7 @@ where
         subgraph_schemas: Option<Arc<HashMap<String, Arc<Valid<Schema>>>>>,
         launch_id: Option<Arc<String>>,
         notify: Notify<String, graphql::Response>,
+        license: LicenseState,
     ) -> Result<Self, BoxError> {
         let config: T = serde_json::from_value(config)?;
         Ok(PluginInit {
@@ -160,11 +170,13 @@ where
             subgraph_schemas: subgraph_schemas.unwrap_or_default(),
             launch_id,
             notify,
+            license,
         })
     }
 
     /// Create a new PluginInit builder
     #[builder(entry = "fake_builder", exit = "build", visibility = "pub")]
+    #[allow(clippy::too_many_arguments)]
     fn fake_new_builder(
         config: T,
         supergraph_sdl: Option<Arc<String>>,
@@ -173,6 +185,7 @@ where
         subgraph_schemas: Option<Arc<HashMap<String, Arc<Valid<Schema>>>>>,
         launch_id: Option<Arc<String>>,
         notify: Option<Notify<String, graphql::Response>>,
+        license: Option<LicenseState>,
     ) -> Self {
         PluginInit {
             config,
@@ -183,6 +196,7 @@ where
             subgraph_schemas: subgraph_schemas.unwrap_or_default(),
             launch_id,
             notify: notify.unwrap_or_else(Notify::for_tests),
+            license: license.unwrap_or_default(),
         }
     }
 }
@@ -200,6 +214,7 @@ impl PluginInit<serde_json::Value> {
             .supergraph_sdl(self.supergraph_sdl)
             .subgraph_schemas(self.subgraph_schemas)
             .notify(self.notify.clone())
+            .license(self.license)
             .build()
     }
 }

apollo-router/src/plugins/connectors/tests/mod.rs

@@ -35,6 +35,7 @@ use crate::router_factory::YamlRouterFactory;
 use crate::services::new_service::ServiceFactory;
 use crate::services::router::Request;
 use crate::services::supergraph;
+use crate::uplink::license_enforcement::LicenseState;
 use crate::Configuration;
 
 mod mock_api;
@@ -1785,6 +1786,7 @@ async fn execute(
             Arc::new(crate::spec::Schema::parse(schema, &config).unwrap()),
             None,
             None,
+            LicenseState::default(),
         )
         .await
         .unwrap();

apollo-router/src/plugins/include_subgraph_errors.rs

@@ -258,9 +258,16 @@ mod test {
 
         let builder = PluggableSupergraphServiceBuilder::new(planner);
 
-        let mut plugins = create_plugins(&configuration, &schema, subgraph_schemas, None, None)
-            .await
-            .unwrap();
+        let mut plugins = create_plugins(
+            &Configuration::default(),
+            &schema,
+            subgraph_schemas,
+            None,
+            None,
+            Default::default(),
+        )
+        .await
+        .unwrap();
 
         plugins.insert("apollo.include_subgraph_errors".to_string(), plugin);
 

apollo-router/src/plugins/limits/mod.rs

@@ -433,6 +433,7 @@ mod test {
         let plugin: PluginTestHarness<LimitsPlugin> = PluginTestHarness::new(
             Some(include_str!("fixtures/content_length_limit.router.yaml")),
             None,
+            None,
         )
         .await;
         plugin

apollo-router/src/plugins/mod.rs

@@ -38,6 +38,7 @@ pub(crate) mod override_url;
 pub(crate) mod progressive_override;
 mod record_replay;
 pub(crate) mod rhai;
+pub(crate) mod router_limits;
 pub(crate) mod subscription;
 pub(crate) mod telemetry;
 #[cfg(test)]