ref(project): Treat invalid project states as pending and unify state types

relay-server/src/endpoints/common.rs

@@ -297,16 +297,18 @@ fn queue_envelope(
     }
 
     // Split off the envelopes by item type.
+    let scoping = managed_envelope.scoping();
     let envelopes = ProcessingGroup::split_envelope(*managed_envelope.take_envelope());
     for (group, envelope) in envelopes {
-        let envelope = buffer_guard
+        let mut envelope = buffer_guard
             .enter(
                 envelope,
                 state.outcome_aggregator().clone(),
                 state.test_store().clone(),
                 group,
             )
             .map_err(BadStoreRequest::QueueFailed)?;
+        envelope.scope(scoping);
         state.project_cache().send(ValidateEnvelope::new(envelope));
     }
     // The entire envelope is taken for a split above, and it's empty at this point, we can just

relay-server/src/endpoints/project_configs.rs

@@ -16,7 +16,7 @@ use crate::endpoints::forward;
 use crate::extractors::SignedJson;
 use crate::service::ServiceState;
 use crate::services::global_config::{self, StatusResponse};
-use crate::services::project::{LimitedProjectState, ProjectState};
+use crate::services::project::{LimitedProjectInfo, ParsedProjectState, ProjectInfo, ProjectState};
 use crate::services::project_cache::{GetCachedProjectState, GetProjectState};
 
 /// V2 version of this endpoint.
@@ -39,6 +39,15 @@ struct VersionQuery {
     version: u16,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase", remote = "ParsedProjectState")]
+struct LimitedParsedProjectState {
+    disabled: bool,
+    #[serde(with = "LimitedProjectInfo")]
+    #[serde(flatten)]
+    info: ProjectInfo,
+}
+
 /// The type returned for each requested project config.
 ///
 /// Wrapper on top the project state which encapsulates information about how ProjectState
@@ -49,13 +58,13 @@ struct VersionQuery {
 #[derive(Debug, Clone, Serialize)]
 #[serde(untagged)]
 enum ProjectStateWrapper {
-    Full(ProjectState),
-    Limited(#[serde(with = "LimitedProjectState")] ProjectState),
+    Full(ParsedProjectState),
+    Limited(#[serde(with = "LimitedParsedProjectState")] ParsedProjectState),
 }
 
 impl ProjectStateWrapper {
     /// Create a wrapper which forces serialization into external or internal format
-    pub fn new(state: ProjectState, full: bool) -> Self {
+    pub fn new(state: ParsedProjectState, full: bool) -> Self {
         if full {
             Self::Full(state)
         } else {
@@ -76,7 +85,7 @@ impl ProjectStateWrapper {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GetProjectStatesResponseWrapper {
-    configs: HashMap<ProjectKey, Option<ProjectStateWrapper>>,
+    configs: HashMap<ProjectKey, ProjectStateWrapper>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pending: Vec<ProjectKey>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -123,7 +132,6 @@ async fn inner(
             project_cache
                 .send(GetProjectState::new(project_key).no_cache(no_cache))
                 .await
-                .map(Some)
         };
 
         (project_key, state_result)
@@ -146,23 +154,36 @@ async fn inner(
     let mut pending = Vec::with_capacity(keys_len);
     let mut configs = HashMap::with_capacity(keys_len);
     for (project_key, state_result) in future::join_all(futures).await {
-        let Some(project_state) = state_result? else {
-            pending.push(project_key);
-            continue;
+        let project_info = match state_result? {
+            ProjectState::Enabled(info) => info,
+            ProjectState::Disabled => {
+                // Don't insert project config. Downstream Relay will consider it disabled.
+                continue;
+            }
+            ProjectState::Pending => {
+                pending.push(project_key);
+                continue;
+            }
         };
 
         // If public key is known (even if rate-limited, which is Some(false)), it has
         // access to the project config
         let has_access = relay.internal
-            || project_state
+            || project_info
                 .config
                 .trusted_relays
                 .contains(&relay.public_key);
 
         if has_access {
             let full = relay.internal && inner.full_config;
-            let wrapper = ProjectStateWrapper::new((*project_state).clone(), full);
-            configs.insert(project_key, Some(wrapper));
+            let wrapper = ProjectStateWrapper::new(
+                ParsedProjectState {
+                    disabled: false,
+                    info: project_info.as_ref().clone(),
+                },
+                full,
+            );
+            configs.insert(project_key, wrapper);
         } else {
             relay_log::debug!(
                 relay = %relay.public_key,

relay-server/src/envelope.rs

@@ -30,6 +30,7 @@
 //!
 //! ```
 
+use relay_base_schema::project::ProjectKey;
 use std::borrow::Borrow;
 use std::collections::BTreeMap;
 use std::fmt;
@@ -52,6 +53,7 @@ use smallvec::SmallVec;
 
 use crate::constants::DEFAULT_EVENT_RETENTION;
 use crate::extractors::{PartialMeta, RequestMeta};
+use crate::services::spooler::QueueKey;
 
 pub const CONTENT_TYPE: &str = "application/x-sentry-envelope";
 
@@ -1218,6 +1220,31 @@ impl Envelope {
         self.headers.sent_at
     }
 
+    /// Returns the project key defined in the `trace` header of the envelope.
+    ///
+    /// This function returns `None` if:
+    ///  - there is no [`DynamicSamplingContext`] in the envelope headers.
+    ///  - there are no transactions or events in the envelope, since in this case sampling by trace is redundant.
+    pub fn sampling_key(&self) -> Option<ProjectKey> {
+        // If the envelope item is not of type transaction or event, we will not return a sampling key
+        // because it doesn't make sense to load the root project state if we don't perform trace
+        // sampling.
+        self.get_item_by(|item| {
+            matches!(
+                item.ty(),
+                ItemType::Transaction | ItemType::Event | ItemType::Span
+            )
+        })?;
+        self.dsc().map(|dsc| dsc.public_key)
+    }
+
+    pub fn queue_key(&self) -> QueueKey {
+        QueueKey {
+            own_key: self.meta().public_key(),
+            sampling_key: self.sampling_key().unwrap_or(self.meta().public_key()),
+        }
+    }
+
     /// Sets the event id on the envelope.
     pub fn set_event_id(&mut self, event_id: EventId) {
         self.headers.event_id = Some(event_id);