feat(server): Use global config from file if provided

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 **Features**:
 
+- Use static global configuration if file is provided. ([#2458](https://github.com/getsentry/relay/pull/2458))
 - Add `view_names` to `AppContext` ([#2344](https://github.com/getsentry/relay/pull/2344))
 - Tag keys in error events and transaction events can now be up to `200` ASCII characters long. Before, tag keys were limited to 32 characters. ([#2453](https://github.com/getsentry/relay/pull/2453))
 

relay-config/Cargo.toml

@@ -20,6 +20,7 @@ num_cpus = "1.13.0"
 relay-auth = { path = "../relay-auth" }
 relay-common = { path = "../relay-common" }
 relay-kafka = { path = "../relay-kafka" }
+relay-dynamic-config = { path = "../relay-dynamic-config" }
 relay-log = { path = "../relay-log", features = ["init"] }
 relay-metrics = { path = "../relay-metrics" }
 relay-redis = { path = "../relay-redis" }

relay-config/src/config.rs

@@ -5,12 +5,14 @@ use std::io::Write;
 use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use std::sync::Arc;
 use std::time::Duration;
 use std::{env, fmt, fs, io};
 
 use anyhow::Context;
 use relay_auth::{generate_key_pair, generate_relay_id, PublicKey, RelayId, SecretKey};
 use relay_common::Dsn;
+use relay_dynamic_config::GlobalConfig;
 use relay_kafka::{
     ConfigError as KafkaConfigError, KafkaConfig, KafkaConfigParam, KafkaTopic, TopicAssignments,
 };
@@ -1250,6 +1252,7 @@ impl ConfigObject for ConfigValues {
 pub struct Config {
     values: ConfigValues,
     credentials: Option<Credentials>,
+    global_config: Option<Arc<GlobalConfig>>,
     path: PathBuf,
 }
 
@@ -1276,6 +1279,7 @@ impl Config {
             } else {
                 None
             },
+            global_config: GlobalConfig::load(&path)?.map(Arc::new),
             path: path.clone(),
         };
 
@@ -1294,6 +1298,7 @@ impl Config {
             values: serde_json::from_value(value)
                 .with_context(|| ConfigError::new(ConfigErrorKind::BadJson))?,
             credentials: None,
+            global_config: None,
             path: PathBuf::new(),
         })
     }
@@ -1470,6 +1475,11 @@ impl Config {
         self.credentials.as_ref()
     }
 
+    /// Return the optional statically configured global config.
+    pub fn global_config(&self) -> Option<Arc<GlobalConfig>> {
+        self.global_config.clone()
+    }
+
     /// Set new credentials.
     ///
     /// This also writes the credentials back to the file.
@@ -2022,6 +2032,7 @@ impl Default for Config {
             values: ConfigValues::default(),
             credentials: None,
             path: PathBuf::new(),
+            global_config: None,
         }
     }
 }

relay-dynamic-config/src/global.rs

@@ -1,3 +1,5 @@
+use std::path::{Path, PathBuf};
+
 use serde::{Deserialize, Serialize};
 
 /// A dynamic configuration for all Relays passed down from Sentry.
@@ -7,3 +9,25 @@ use serde::{Deserialize, Serialize};
 #[derive(Default, Clone, Debug, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct GlobalConfig {}
+
+impl GlobalConfig {
+    /// The full filename of the global config file, including the file extension.
+    fn path(base: &Path) -> PathBuf {
+        base.join("global_config.json")
+    }
+
+    /// Loads the [`GlobalConfig`] from a file if it's provided.
+    pub fn load(base: &Path) -> anyhow::Result<Option<Self>> {
+        let path = Self::path(base);
+
+        match path.exists() {
+            true => {
+                let file_contents = std::fs::read_to_string(path)?;
+                let global_config = serde_json::from_str::<GlobalConfig>(file_contents.as_str())?;
+
+                Ok(Some(global_config))
+            }
+            false => Ok(None),
+        }
+    }
+}

relay-server/src/actors/global_config.rs

@@ -13,6 +13,7 @@ use std::borrow::Cow;
 use std::sync::Arc;
 
 use relay_config::Config;
+use relay_config::RelayMode;
 use relay_dynamic_config::GlobalConfig;
 use relay_statsd::metric;
 use relay_system::{Addr, AsyncResponse, Controller, FromMessage, Interface, Service};
@@ -148,8 +149,39 @@ pub struct GlobalConfigService {
 impl GlobalConfigService {
     /// Creates a new [`GlobalConfigService`].
     pub fn new(config: Arc<Config>, upstream: Addr<UpstreamRelay>) -> Self {
-        let (global_config_watch, _) = watch::channel(Arc::default());
         let (internal_tx, internal_rx) = mpsc::channel(1);
+
+        let (global_config_watch, _) = match (
+            config.relay_mode(),
+            config.has_credentials(),
+            config.global_config(),
+        ) {
+            (RelayMode::Proxy | RelayMode::Static, true, None) | (RelayMode::Managed, true, _) => {
+                relay_log::info!("global config service starting");
+                // This request will trigger the request intervals when internal_rx receives the
+                // result from upstream.
+                Self::request_global_config(upstream.clone(), internal_tx.clone());
+                watch::channel(Arc::new(GlobalConfig::default()))
+            }
+            (RelayMode::Proxy | RelayMode::Static, false, None)
+            | (RelayMode::Managed, false, _) => {
+                // NOTE(iker): not making a request results in the sleep handler
+                // not being reset, so no new requests are made.
+                relay_log::info!("global config service starting with fetching disabled: no credentials configured");
+                watch::channel(Arc::new(GlobalConfig::default()))
+            }
+            (RelayMode::Proxy | RelayMode::Static | RelayMode::Capture, _, Some(global_config)) => {
+                relay_log::info!("global config service starting with fetching disabled: using static global config");
+                watch::channel(global_config.clone())
+            }
+            (RelayMode::Capture, _, None) => {
+                relay_log::info!(
+                    "global config service starting with fetching disabled: using default config"
+                );
+                watch::channel(Arc::new(GlobalConfig::default()))
+            }
+        };
+
         Self {
             config,
             global_config_watch,
@@ -185,12 +217,10 @@ impl GlobalConfigService {
     ///
     /// We check if we have credentials before sending,
     /// otherwise we would log an [`UpstreamRequestError::NoCredentials`] error.
-    fn update_global_config(&mut self) {
-        self.fetch_handle.reset();
-
-        let upstream_relay = self.upstream.clone();
-        let internal_tx = self.internal_tx.clone();
-
+    fn request_global_config(
+        upstream_relay: Addr<UpstreamRelay>,
+        internal_tx: mpsc::Sender<UpstreamQueryResult>,
+    ) {
         tokio::spawn(async move {
             metric!(timer(RelayTimers::GlobalConfigRequestDuration), {
                 let query = GetGlobalConfig::new();
@@ -209,7 +239,7 @@ impl GlobalConfigService {
     /// 1. Whether the request to the upstream was successful.
     /// 2. If the request was successful, it then checks whether the returned
     /// global config is valid and contains the expected data.
-    fn handle_result(&mut self, result: UpstreamQueryResult) {
+    fn handle_upstream_result(&mut self, result: UpstreamQueryResult) {
         match result {
             Ok(Ok(config)) => {
                 let mut success = false;
@@ -253,25 +283,15 @@ impl Service for GlobalConfigService {
         tokio::spawn(async move {
             let mut shutdown_handle = Controller::shutdown_handle();
 
-            relay_log::info!("global config service starting");
-
-            if self.config.has_credentials() {
-                // NOTE(iker): if this first request fails it's possible the default
-                // global config is forwarded. This is not ideal, but we accept it
-                // for now.
-                self.update_global_config();
-            } else {
-                // NOTE(iker): not making a request results in the sleep handler
-                // not being reset, so no new requests are made.
-                relay_log::info!("fetching global configs disabled: no credentials configured");
-            }
-
             loop {
                 tokio::select! {
                     biased;
-
-                    () = &mut self.fetch_handle => self.update_global_config(),
-                    Some(result) = self.internal_rx.recv() => self.handle_result(result),
+                    () = &mut self.fetch_handle => {
+                        Self::request_global_config(self.upstream.clone(), self.internal_tx.clone());
+                        // Disable new requests interval until we receive the result from upstream.
+                        self.fetch_handle.reset();
+                    }
+                    Some(result) = self.internal_rx.recv() => self.handle_upstream_result(result),
                     Some(message) = rx.recv() => self.handle_message(message),
                     _ = shutdown_handle.notified() => self.handle_shutdown(),