diff --git a/relay-server/src/processing/profiles/mod.rs b/relay-server/src/processing/profiles/mod.rs index e15b75e5e0c..37eef1cbe64 100644 --- a/relay-server/src/processing/profiles/mod.rs +++ b/relay-server/src/processing/profiles/mod.rs @@ -10,7 +10,6 @@ use crate::managed::{ }; use crate::processing::{Context, CountRateLimited, Output, Processor, QuotaRateLimiter}; use crate::services::outcome::{DiscardReason, Outcome}; -use crate::statsd::RelayCounters; mod filter; mod forward; @@ -101,12 +100,6 @@ impl Processor for ProfilesProcessor { profiles: Managed, ctx: Context<'_>, ) -> Result, Rejected> { - relay_statsd::metric!( - counter(RelayCounters::StandaloneItem) += profiles.profiles.len() as u64, - processor = "new", - item_type = "profile", - ); - filter::feature_flag(ctx).reject(&profiles)?; let profile = process::expand(profiles)?; diff --git a/relay-server/src/processing/transactions/types/output.rs b/relay-server/src/processing/transactions/types/output.rs index 965d40c6aeb..aa0c14445f8 100644 --- a/relay-server/src/processing/transactions/types/output.rs +++ b/relay-server/src/processing/transactions/types/output.rs @@ -1,7 +1,3 @@ -#[cfg(test)] -use relay_event_schema::protocol::Event; -#[cfg(test)] -use relay_protocol::Annotated; use relay_quotas::DataCategory; use crate::Envelope; @@ -26,17 +22,6 @@ pub enum TransactionOutput { Indexed(Managed>>), } -impl TransactionOutput { - #[cfg(test)] - pub fn event(self) -> Option> { - match self { - TransactionOutput::Full(managed) => Some(managed.accept(|x| x).event), - TransactionOutput::Profile(_) => None, - TransactionOutput::Indexed(managed) => Some(managed.accept(|x| x).event), - } - } -} - impl Forward for TransactionOutput { fn serialize_envelope( self, diff --git a/relay-server/src/processing/user_reports/mod.rs b/relay-server/src/processing/user_reports/mod.rs index 0cbc9d1e199..7e9022fdaea 100644 --- a/relay-server/src/processing/user_reports/mod.rs +++ b/relay-server/src/processing/user_reports/mod.rs @@ -6,7 +6,6 @@ use crate::envelope::{EnvelopeHeaders, Item, ItemType}; use crate::managed::{Counted, Managed, ManagedEnvelope, OutcomeError, Quantities, Rejected}; use crate::processing::{Context, CountRateLimited, Output, Processor, QuotaRateLimiter}; use crate::services::outcome::Outcome; -use crate::statsd::RelayCounters; mod forward; mod process; @@ -87,12 +86,6 @@ impl Processor for UserReportsProcessor { mut reports: Managed, ctx: Context<'_>, ) -> Result, Rejected> { - relay_statsd::metric!( - counter(RelayCounters::StandaloneItem) += reports.reports.len() as u64, - processor = "new", - item_type = "user_report", - ); - process::process(&mut reports); let reports = self.limiter.enforce_quotas(reports, ctx).await?; diff --git a/relay-server/src/services/processor.rs b/relay-server/src/services/processor.rs index f594e1ba421..f5020b586c4 100644 --- a/relay-server/src/services/processor.rs +++ b/relay-server/src/services/processor.rs @@ -90,14 +90,11 @@ use { pub mod event; mod metrics; mod nel; -mod profile; -mod report; #[cfg(feature = "processing")] mod span; #[cfg(all(sentry, feature = "processing"))] pub mod playstation; -mod standalone; /// Creates the block only if used with `processing` feature. /// @@ -168,13 +165,6 @@ processing_group!(TransactionGroup, Transaction); processing_group!(ErrorGroup, Error); processing_group!(SessionGroup, Session); -processing_group!( - StandaloneGroup, - Standalone, - StandaloneAttachments, - StandaloneUserReports, - StandaloneProfiles -); processing_group!(ClientReportGroup, ClientReport); processing_group!(ReplayGroup, Replay); processing_group!(CheckInGroup, CheckIn); @@ -207,9 +197,6 @@ pub enum ProcessingGroup { Error, /// Session events. Session, - /// Standalone items which can be sent alone without any event attached to it in the current - /// envelope e.g. some attachments, user reports. - Standalone, /// Standalone attachments /// /// Attachments that are send without an item that creates an event in the same envelope. @@ -403,20 +390,6 @@ impl ProcessingGroup { } } - // Extract all standalone items. - // - // Note: only if there are no items in the envelope which can create events, otherwise they - // will be in the same envelope with all require event items. - if !envelope.items().any(Item::creates_event) { - let standalone_items = envelope.take_items_by(Item::requires_event); - if !standalone_items.is_empty() { - grouped_envelopes.push(( - ProcessingGroup::Standalone, - Envelope::from_parts(headers.clone(), standalone_items), - )) - } - }; - // Make sure we create separate envelopes for each `RawSecurity` report. let security_reports_items = envelope .take_items_by(|i| matches!(i.ty(), &ItemType::RawSecurity)) @@ -478,7 +451,6 @@ impl ProcessingGroup { ProcessingGroup::Transaction => "transaction", ProcessingGroup::Error => "error", ProcessingGroup::Session => "session", - ProcessingGroup::Standalone => "standalone", ProcessingGroup::StandaloneAttachments => "standalone_attachment", ProcessingGroup::StandaloneUserReports => "standalone_user_reports", ProcessingGroup::StandaloneProfiles => "standalone_profiles", @@ -505,7 +477,6 @@ impl From for AppFeature { ProcessingGroup::Transaction => AppFeature::Transactions, ProcessingGroup::Error => AppFeature::Errors, ProcessingGroup::Session => AppFeature::Sessions, - ProcessingGroup::Standalone => AppFeature::UnattributedEnvelope, ProcessingGroup::StandaloneAttachments => AppFeature::UnattributedEnvelope, ProcessingGroup::StandaloneUserReports => AppFeature::UserReports, ProcessingGroup::StandaloneProfiles => AppFeature::Profiles, @@ -600,6 +571,9 @@ pub enum ProcessingError { #[cfg(feature = "processing")] #[error("invalid attachment reference")] InvalidAttachmentRef, + + #[error("could not determine processing group for envelope items")] + NoProcessingGroup, } impl ProcessingError { @@ -645,6 +619,7 @@ impl ProcessingError { Self::InvalidAttachmentRef => { Some(Outcome::Invalid(DiscardReason::InvalidAttachmentRef)) } + Self::NoProcessingGroup => Some(Outcome::Invalid(DiscardReason::Internal)), } } @@ -823,17 +798,6 @@ fn send_metrics( } } -/// Function for on-off switches that filter specific item types (profiles, spans) -/// based on a feature flag. -/// -/// If the project config did not come from the upstream, we keep the items. -fn should_filter(config: &Config, project_info: &ProjectInfo, feature: Feature) -> bool { - match config.relay_mode() { - RelayMode::Proxy => false, - RelayMode::Managed => !project_info.has_feature(feature), - } -} - /// The result of the envelope processing containing the processed envelope along with the partial /// result. #[derive(Debug)] @@ -1326,44 +1290,6 @@ impl EnvelopeProcessorService { } else { Ok(cached_result.event) }) } - /// Processes standalone items that require an event ID, but do not have an event on the same envelope. - async fn process_standalone( - &self, - managed_envelope: &mut TypedEnvelope, - ctx: processing::Context<'_>, - ) -> Result, ProcessingError> { - for item in managed_envelope.envelope().items() { - let attachment_type_tag = match item.attachment_type() { - Some(t) => &t.to_string(), - None => "", - }; - relay_statsd::metric!( - counter(RelayCounters::StandaloneItem) += 1, - processor = "old", - item_type = item.ty().name(), - attachment_type = attachment_type_tag, - ); - } - - let mut extracted_metrics = ProcessingExtractedMetrics::new(); - - standalone::process(managed_envelope); - - profile::filter(managed_envelope, ctx.config, ctx.project_info); - - self.enforce_quotas( - managed_envelope, - Annotated::empty(), - &mut extracted_metrics, - ctx, - ) - .await?; - - report::process_user_reports(managed_envelope); - - Ok(Some(extracted_metrics)) - } - async fn process_nel( &self, mut managed_envelope: ManagedEnvelope, @@ -1530,7 +1456,6 @@ impl EnvelopeProcessorService { self.process_with_processor(&self.inner.processing.sessions, managed_envelope, ctx) .await } - ProcessingGroup::Standalone => run!(process_standalone, ctx), ProcessingGroup::StandaloneAttachments => { self.process_with_processor( &self.inner.processing.attachments, @@ -1625,9 +1550,7 @@ impl EnvelopeProcessorService { "could not identify the processing group based on the envelope's items" ); - Ok(ProcessingResult::no_metrics( - managed_envelope.into_processed(), - )) + Err(ProcessingError::NoProcessingGroup) } // Leave this group unchanged. // diff --git a/relay-server/src/services/processor/profile.rs b/relay-server/src/services/processor/profile.rs deleted file mode 100644 index 1484165fa20..00000000000 --- a/relay-server/src/services/processor/profile.rs +++ /dev/null @@ -1,388 +0,0 @@ -//! Profiles related processor code. - -use relay_dynamic_config::Feature; - -use relay_config::Config; -use relay_profiling::ProfileError; - -use crate::envelope::ItemType; -use crate::managed::{ItemAction, TypedEnvelope}; -use crate::services::outcome::{DiscardReason, Outcome}; -use crate::services::processor::should_filter; -use crate::services::projects::project::ProjectInfo; - -pub fn filter( - managed_envelope: &mut TypedEnvelope, - config: &Config, - project_info: &ProjectInfo, -) { - let profiling_disabled = should_filter(config, project_info, Feature::Profiling); - - let mut saw_profile = false; - managed_envelope.retain_items(|item| match item.ty() { - ItemType::Profile if profiling_disabled => ItemAction::DropSilently, - // First profile found in the envelope, we'll keep it if metadata are valid. - ItemType::Profile if !saw_profile => { - // Drop profile without a transaction in the same envelope, - // except if unsampled profiles are allowed for this project. - let profile_allowed = !item.sampled(); - if !profile_allowed { - return ItemAction::DropSilently; - } - - match relay_profiling::parse_metadata(&item.payload()) { - Ok(_) => { - saw_profile = true; - ItemAction::Keep - } - Err(err) => ItemAction::Drop(Outcome::Invalid(DiscardReason::Profiling( - relay_profiling::discard_reason(&err), - ))), - } - } - // We found another profile, we'll drop it. - ItemType::Profile => ItemAction::Drop(Outcome::Invalid(DiscardReason::Profiling( - relay_profiling::discard_reason(&ProfileError::TooManyProfiles), - ))), - _ => ItemAction::Keep, - }); -} - -#[cfg(test)] -mod tests { - use crate::envelope::{ContentType, Envelope, Item}; - use crate::extractors::RequestMeta; - use crate::managed::ManagedEnvelope; - use crate::processing::{self, Outputs}; - use crate::services::processor::{ProcessEnvelopeGrouped, ProcessingGroup}; - use crate::services::processor::{ProcessingError, Submit}; - use crate::services::projects::project::ProjectInfo; - use crate::testutils::create_test_processor; - use insta::assert_debug_snapshot; - use relay_dynamic_config::{Feature, GlobalConfig}; - use relay_event_schema::protocol::{Event, EventId, ProfileContext}; - use relay_protocol::Annotated; - use relay_system::Addr; - - use super::*; - - async fn process_event(envelope: Box) -> Result, ProcessingError> { - let config = Config::from_json_value(serde_json::json!({ - "processing": { - "enabled": true, - "kafka_config": [] - } - })) - .unwrap(); - let processor = create_test_processor(config).await; - let mut envelopes = ProcessingGroup::split_envelope(*envelope, &Default::default()); - assert_eq!(envelopes.len(), 1); - let (group, envelope) = envelopes.pop().unwrap(); - - let envelope = ManagedEnvelope::new(envelope, Addr::dummy()); - - let mut project_info = ProjectInfo::default().sanitized(false); - project_info.config.features.0.insert(Feature::Profiling); - - let global_config = GlobalConfig::default(); - let message = ProcessEnvelopeGrouped { - group, - envelope, - ctx: processing::Context { - config: &processor.inner.config, - project_info: &project_info, - global_config: &global_config, - ..processing::Context::for_test() - }, - }; - - let result = processor.process(message).await?; - - let Some(Submit::Output { - output: Outputs::Transactions(t), - ctx: _, - }) = result - else { - panic!(); - }; - Ok(t.event().unwrap()) - } - - #[tokio::test] - async fn test_profile_id_transfered() { - relay_log::init_test!(); - - let event_id = EventId::new(); - let dsn = "https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42" - .parse() - .unwrap(); - let request_meta = RequestMeta::new(dsn); - let mut envelope = Envelope::from_request(Some(event_id), request_meta); - - // Add a valid transaction item. - envelope.add_item({ - let mut item = Item::new(ItemType::Transaction); - - item.set_payload( - ContentType::Json, - r#"{ - "event_id": "9b73438f70e044ecbd006b7fd15b7373", - "type": "transaction", - "transaction": "/foo/", - "timestamp": 946684810.0, - "start_timestamp": 946684800.0, - "contexts": { - "trace": { - "trace_id": "4c79f60c11214eb38604f4ae0781bfb2", - "span_id": "fa90fdead5f74053", - "op": "http.server", - "type": "trace" - } - }, - "transaction_info": { - "source": "url" - } - }"#, - ); - item - }); - - // Add a profile to the same envelope. - envelope.add_item({ - let mut item = Item::new(ItemType::Profile); - item.set_payload( - ContentType::Json, - r#"{ - "profile_id": "012d836b15bb49d7bbf99e64295d995b", - "version": "1", - "platform": "android", - "os": {"name": "foo", "version": "bar"}, - "device": {"architecture": "zap"}, - "timestamp": "2023-10-10 00:00:00Z", - "profile": { - "samples":[ - { - "stack_id":0, - "elapsed_since_start_ns":1, - "thread_id":1 - }, - { - "stack_id":0, - "elapsed_since_start_ns":2, - "thread_id":1 - } - ], - "stacks":[[0]], - "frames":[{ - "function":"main" - }] - }, - "transactions": [ - { - "id": "9b73438f70e044ecbd006b7fd15b7373", - "name": "/foo/", - "trace_id": "4c79f60c11214eb38604f4ae0781bfb2" - } - ] - }"#, - ); - item - }); - - let event = process_event(envelope).await.unwrap(); - - let context = event.value().unwrap().context::().unwrap(); - - assert_debug_snapshot!(context, @r###" - ProfileContext { - profile_id: EventId( - 012d836b-15bb-49d7-bbf9-9e64295d995b, - ), - profiler_id: ~, - } - "###); - } - - #[tokio::test] - async fn test_invalid_profile_id_not_transfered() { - // Setup - let event_id = EventId::new(); - let dsn = "https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42" - .parse() - .unwrap(); - let request_meta = RequestMeta::new(dsn); - let mut envelope = Envelope::from_request(Some(event_id), request_meta); - - // Add a valid transaction item. - envelope.add_item({ - let mut item = Item::new(ItemType::Transaction); - - item.set_payload( - ContentType::Json, - r#"{ - "event_id": "9b73438f70e044ecbd006b7fd15b7373", - "type": "transaction", - "transaction": "/foo/", - "timestamp": 946684810.0, - "start_timestamp": 946684800.0, - "contexts": { - "trace": { - "trace_id": "4c79f60c11214eb38604f4ae0781bfb2", - "span_id": "fa90fdead5f74053", - "op": "http.server", - "type": "trace" - } - }, - "transaction_info": { - "source": "url" - } - }"#, - ); - item - }); - - // Add a profile to the same envelope. - envelope.add_item({ - let mut item = Item::new(ItemType::Profile); - item.set_payload( - ContentType::Json, - r#"{ - "profile_id": "012d836b15bb49d7bbf99e64295d995b", - "version": "1", - "platform": "android", - "os": {"name": "foo", "version": "bar"}, - "device": {"architecture": "zap"}, - "timestamp": "2023-10-10 00:00:00Z", - "profile": { - "samples":[ - { - "stack_id":0, - "elapsed_since_start_ns":1, - "thread_id":1 - }, - { - "stack_id":1, - "elapsed_since_start_ns":2, - "thread_id":1 - } - ], - "stacks":[[0],[]], - "frames":[{ - "function":"main" - }] - }, - "transactions": [ - { - "id": "9b73438f70e044ecbd006b7fd15b7373", - "name": "/foo/", - "trace_id": "4c79f60c11214eb38604f4ae0781bfb2" - } - ] - }"#, - ); - item - }); - - let event = process_event(envelope).await.unwrap(); - let context = event.value().unwrap().context::().unwrap(); - - assert_debug_snapshot!(context, @r###" - ProfileContext { - profile_id: ~, - profiler_id: ~, - } - "###); - } - - #[tokio::test] - async fn filter_standalone_profile() { - relay_log::init_test!(); - // Setup - let event_id = EventId::new(); - let dsn = "https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42" - .parse() - .unwrap(); - let request_meta = RequestMeta::new(dsn); - let mut envelope = Envelope::from_request(Some(event_id), request_meta); - - // Add a profile to the same envelope. - envelope.add_item({ - let mut item = Item::new(ItemType::Profile); - item.set_payload( - ContentType::Json, - r#"{ - "profile_id": "012d836b15bb49d7bbf99e64295d995b", - "version": "1", - "platform": "android", - "os": {"name": "foo", "version": "bar"}, - "device": {"architecture": "zap"}, - "timestamp": "2023-10-10 00:00:00Z" - }"#, - ); - item - }); - - let event = process_event(envelope).await; - assert!(matches!( - event.unwrap_err(), - ProcessingError::ProcessingFailure - )); - } - - #[tokio::test] - async fn test_profile_id_removed_profiler_id_kept() { - let event_id = EventId::new(); - let dsn = "https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42" - .parse() - .unwrap(); - let request_meta = RequestMeta::new(dsn); - let mut envelope = Envelope::from_request(Some(event_id), request_meta); - - // Add a valid transaction item. - envelope.add_item({ - let mut item = Item::new(ItemType::Transaction); - - item.set_payload( - ContentType::Json, - r#"{ - "type": "transaction", - "transaction": "/foo/", - "timestamp": 946684810.0, - "start_timestamp": 946684800.0, - "contexts": { - "trace": { - "trace_id": "4c79f60c11214eb38604f4ae0781bfb2", - "span_id": "fa90fdead5f74053", - "op": "http.server", - "type": "trace" - }, - "profile": { - "profile_id": "4c79f60c11214eb38604f4ae0781bfb2", - "profiler_id": "4c79f60c11214eb38604f4ae0781bfb2", - "type": "profile" - } - }, - "transaction_info": { - "source": "url" - } - }"#, - ); - item - }); - - let mut project_info = ProjectInfo::default(); - project_info.config.features.0.insert(Feature::Profiling); - - let event = process_event(envelope).await.unwrap(); - let context = event.value().unwrap().context::().unwrap(); - - assert_debug_snapshot!(context, @r###" - ProfileContext { - profile_id: ~, - profiler_id: EventId( - 4c79f60c-1121-4eb3-8604-f4ae0781bfb2, - ), - } - "###); - } -} diff --git a/relay-server/src/services/processor/report.rs b/relay-server/src/services/processor/report.rs deleted file mode 100644 index 6af44503cfc..00000000000 --- a/relay-server/src/services/processor/report.rs +++ /dev/null @@ -1,131 +0,0 @@ -//! Contains code related to validation and normalization of the user reports. - -use std::error::Error; - -use relay_event_schema::protocol::UserReport; - -use crate::envelope::{ContentType, ItemType}; -use crate::managed::{ItemAction, TypedEnvelope}; -use crate::services::outcome::{DiscardReason, Outcome}; - -/// Validates and normalizes all user report items in the envelope. -/// -/// User feedback items are removed from the envelope if they contain invalid JSON or if the -/// JSON violates the schema (basic type validation). Otherwise, their normalized representation -/// is written back into the item. -pub fn process_user_reports(managed_envelope: &mut TypedEnvelope) { - managed_envelope.retain_items(|item| { - if item.ty() != &ItemType::UserReport { - return ItemAction::Keep; - }; - - let payload = item.payload(); - // There is a customer SDK which sends invalid reports with a trailing `\n`, - // strip it here, even if they update/fix their SDK there will still be many old - // versions with the broken SDK out there. - let payload = trim_whitespaces(&payload); - let report = match serde_json::from_slice::(payload) { - Ok(report) => report, - Err(error) => { - relay_log::debug!( - error = &error as &dyn Error, - "failed to deserialize user report" - ); - return ItemAction::Drop(Outcome::Invalid(DiscardReason::InvalidJson)); - } - }; - - let json_string = match serde_json::to_string(&report) { - Ok(json) => json, - Err(err) => { - relay_log::error!( - error = &err as &dyn Error, - "failed to serialize user report" - ); - return ItemAction::Drop(Outcome::Invalid(DiscardReason::Internal)); - } - }; - - item.set_payload(ContentType::Json, json_string); - ItemAction::Keep - }); -} - -fn trim_whitespaces(data: &[u8]) -> &[u8] { - let Some(from) = data.iter().position(|x| !x.is_ascii_whitespace()) else { - return &[]; - }; - let Some(to) = data.iter().rposition(|x| !x.is_ascii_whitespace()) else { - return &[]; - }; - &data[from..to + 1] -} - -#[cfg(test)] -mod tests { - use relay_event_schema::protocol::EventId; - use relay_system::Addr; - - use crate::envelope::{Envelope, Item}; - use crate::extractors::RequestMeta; - use crate::managed::ManagedEnvelope; - use crate::processing::{self, Forward}; - use crate::services::processor::{ProcessEnvelopeGrouped, ProcessingGroup, Submit}; - use crate::testutils::create_test_processor; - - use super::*; - - #[tokio::test] - async fn test_user_report_invalid() { - let processor = create_test_processor(Default::default()).await; - let outcome_aggregator = Addr::dummy(); - let event_id = EventId::new(); - - let dsn = "https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42" - .parse() - .unwrap(); - - let request_meta = RequestMeta::new(dsn); - let mut envelope = Envelope::from_request(Some(event_id), request_meta); - - envelope.add_item({ - let mut item = Item::new(ItemType::UserReport); - item.set_payload(ContentType::Json, r#"{"foo": "bar"}"#); - item - }); - - envelope.add_item({ - let mut item = Item::new(ItemType::Event); - item.set_payload(ContentType::Json, "{}"); - item - }); - - let mut envelopes = ProcessingGroup::split_envelope(*envelope, &Default::default()); - assert_eq!(envelopes.len(), 1); - let (group, envelope) = envelopes.pop().unwrap(); - let envelope = ManagedEnvelope::new(envelope, outcome_aggregator); - - let message = ProcessEnvelopeGrouped { - group, - envelope, - ctx: processing::Context::for_test(), - }; - - let Ok(Some(Submit::Output { output, ctx })) = processor.process(message).await else { - panic!(); - }; - let new_envelope = output.serialize_envelope(ctx).unwrap(); - - assert_eq!(new_envelope.len(), 1); - assert_eq!(new_envelope.items().next().unwrap().ty(), &ItemType::Event); - } - - #[test] - fn test_trim_whitespaces() { - assert_eq!(trim_whitespaces(b""), b""); - assert_eq!(trim_whitespaces(b" \n\r "), b""); - assert_eq!(trim_whitespaces(b" \nx\r "), b"x"); - assert_eq!(trim_whitespaces(b" {foo: bar} "), b"{foo: bar}"); - assert_eq!(trim_whitespaces(b"{ foo: bar}"), b"{ foo: bar}"); - } -} diff --git a/relay-server/src/services/processor/standalone.rs b/relay-server/src/services/processor/standalone.rs deleted file mode 100644 index a20c3944136..00000000000 --- a/relay-server/src/services/processor/standalone.rs +++ /dev/null @@ -1,14 +0,0 @@ -use crate::envelope::ItemType; -use crate::managed::{ItemAction, TypedEnvelope}; -use crate::services::processor::StandaloneGroup; - -/// Processes a standalone envelope by removing unnecessary items. -/// -/// This function removes form data items from the envelope since they are not allowed in -/// standalone processing. -pub fn process(managed_envelope: &mut TypedEnvelope) { - managed_envelope.retain_items(|i| match i.ty() { - ItemType::FormData => ItemAction::DropSilently, - _ => ItemAction::Keep, - }); -} diff --git a/relay-server/src/statsd.rs b/relay-server/src/statsd.rs index 1d7700464d5..e47fbc913ce 100644 --- a/relay-server/src/statsd.rs +++ b/relay-server/src/statsd.rs @@ -993,12 +993,6 @@ pub enum RelayCounters { /// This metric is tagged with: /// - `expansion`: What expansion was used to expand the error (e.g. unreal). ErrorProcessed, - /// Number of 'standalone' items. - /// - /// This metric is tagged with: - /// - `item_type`: The type of the item. - /// - `attachment_type`: The attachment type of the item, if any. - StandaloneItem, } impl CounterMetric for RelayCounters { @@ -1058,7 +1052,6 @@ impl CounterMetric for RelayCounters { RelayCounters::EnvelopeWithLogs => "logs.envelope", RelayCounters::ProfileChunksWithoutPlatform => "profile_chunk.no_platform", RelayCounters::ErrorProcessed => "event.error.processed", - RelayCounters::StandaloneItem => "processing.standalone_item", } } }