graph, graphql: Configure window and bin sizes for stats through environment

Author: lutter

docs/environment-variables.md

@@ -112,3 +112,8 @@ those.
   Due to implementation details, this value may not be strictly adhered to. Defaults to 10.
 - `GRAPH_LOG_POI_EVENTS`: Logs Proof of Indexing events deterministically.
   This may be useful for debugging.
+- `GRAPH_LOAD_WINDOW_SIZE`, `GRAPH_LOAD_BIN_SIZE`: Load can be
+  automatically throttled if load measurements over a time period of
+  `GRAPH_LOAD_WINDOW_SIZE` seconds exceed a threshold. Measurements within
+  each window are binned into bins of `GRAPH_LOAD_BIN_SIZE` seconds. The
+  variables default to 300s and 1s

graph/src/data/graphql/effort.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 
-use crate::util::stats::MovingStats;
+use crate::util::stats::{MovingStats, BIN_SIZE, WINDOW_SIZE};
 
 pub struct QueryEffort {
     inner: Arc<RwLock<QueryEffortInner>>,
@@ -19,6 +19,14 @@ struct QueryEffortInner {
     total: MovingStats,
 }
 
+/// Create a `QueryEffort` that uses the window and bin sizes configured in
+/// the environment
+impl Default for QueryEffort {
+    fn default() -> Self {
+        Self::new(*WINDOW_SIZE, *BIN_SIZE)
+    }
+}
+
 impl QueryEffort {
     pub fn new(window_size: Duration, bin_size: Duration) -> Self {
         Self {

graph/src/util/stats.rs

@@ -1,6 +1,35 @@
 use std::collections::VecDeque;
+use std::env;
+use std::str::FromStr;
 use std::time::{Duration, Instant};
 
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub static ref WINDOW_SIZE: Duration = {
+        let window_size = env::var("GRAPH_LOAD_WINDOW_SIZE")
+            .ok()
+            .map(|s| {
+                u64::from_str(&s).unwrap_or_else(|_| {
+                    panic!("GRAPH_LOAD_WINDOW_SIZE must be a number, but is `{}`", s)
+                })
+            })
+            .unwrap_or(300);
+        Duration::from_secs(window_size)
+    };
+    pub static ref BIN_SIZE: Duration = {
+        let bin_size = env::var("GRAPH_LOAD_BIN_SIZE")
+            .ok()
+            .map(|s| {
+                u64::from_str(&s).unwrap_or_else(|_| {
+                    panic!("GRAPH_LOAD_BIN_SIZE must be a number but is `{}`", s)
+                })
+            })
+            .unwrap_or(1);
+        Duration::from_secs(bin_size)
+    };
+}
+
 /// One bin of durations. The bin starts at time `start`, and we've added `count`
 /// entries to it whose durations add up to `duration`
 struct Bin {
@@ -61,6 +90,14 @@ pub struct MovingStats {
     total: Bin,
 }
 
+/// Create `MovingStats` that use the window and bin sizes configured in
+/// the environment
+impl Default for MovingStats {
+    fn default() -> Self {
+        Self::new(*WINDOW_SIZE, *BIN_SIZE)
+    }
+}
+
 impl MovingStats {
     pub fn new(window_size: Duration, bin_size: Duration) -> Self {
         let capacity = if bin_size.as_millis() > 0 {

graphql/src/runner.rs

@@ -49,8 +49,6 @@ lazy_static! {
         .map(|s| u32::from_str(&s)
             .unwrap_or_else(|_| panic!("failed to parse env var GRAPH_GRAPHQL_MAX_FIRST")))
         .unwrap_or(1000);
-    static ref WINDOW_SIZE: Duration = Duration::from_secs(300);
-    static ref BIN_SIZE: Duration = Duration::from_secs(1);
 }
 
 impl<S> GraphQlRunner<S>
@@ -67,7 +65,7 @@ where
             logger: logger.new(o!("component" => "GraphQlRunner")),
             store,
             expensive,
-            effort: Arc::new(QueryEffort::new(*WINDOW_SIZE, *BIN_SIZE)),
+            effort: Arc::new(QueryEffort::default()),
         }
     }