relay_profiling/

lib.rs

//! Profiling protocol and processing for Sentry.
//!
//! Profiles are captured during the life of a transaction on Sentry clients and sent to Relay for
//! ingestion as JSON objects with some metadata. They are sent alongside a transaction (usually in
//! the same envelope) and are usually big objects (average size around 300KB and it's not unusual
//! to see several MB). Their size is linked to the amount of code executed during the transaction
//! (so the duration of the transaction influences the size of the profile).
//!
//! It's preferrable to have a profile with a transaction. If a transaction is dropped, the profile
//! should be dropped as well.
//!
//! # Envelope
//!
//! ## Transaction Profiling
//!
//! To send a profile of a transaction to Relay, the profile is enclosed in an item of type
//! `profile`:
//! ```json
//! {"type": "profile", "size": ...}
//! { ... }
//! ```
//! ## Continuous Profiling
//!
//! For continuous profiling, we expect to receive chunks of profile in an item of type
//! `profile_chunk`:
//! ```json
//! {"type": "profile_chunk"}
//! { ... }
//! ```
//!
//! # Protocol
//!
//! Each item type expects a different format.
//!
//! For `Profile` item type, we expect the Sample format v1 or Android format.
//! For `ProfileChunk` item type, we expect the Sample format v2.
//!
//! # Ingestion
//!
//! Relay will forward those profiles encoded with `msgpack` after unpacking them if needed and push a message on Kafka.

use std::error::Error;
use std::net::IpAddr;
use std::time::Duration;

use relay_dynamic_config::GlobalConfig;
use relay_event_schema::protocol::{Event, EventId};
use relay_filter::ProjectFiltersConfig;
use serde_json::Deserializer;

use crate::extract_from_transaction::{extract_transaction_metadata, extract_transaction_tags};

pub use crate::error::ProfileError;
pub use crate::outcomes::discard_reason;

mod android;
mod debug_image;
mod error;
mod extract_from_transaction;
mod measurements;
mod outcomes;
mod perfetto;
mod profile_chunk;
mod sample;
mod transaction_metadata;
mod types;
mod utils;

pub use self::android::chunk::Chunk as AndroidProfileChunk;
pub use self::perfetto::Chunk as PerfettoProfileChunk;
pub use self::profile_chunk::{AndroidOrV2ProfileChunk, AnyProfileChunk, ProfileChunk};
pub use self::sample::v2::ProfileChunk as V2ProfileChunk;

const MAX_PROFILE_DURATION: Duration = Duration::from_secs(30);
/// For continuous profiles, each chunk can be at most 1 minute.
/// In certain circumstances (e.g. high cpu load) the profiler
/// the profiler may be stopped slightly after 60, hence here we
/// give it a bit more room to handle such cases (66 instead of 60)
const MAX_PROFILE_CHUNK_DURATION: Duration = Duration::from_secs(66);

/// Prefix used in [`relay_protocol::Getter`] implementations as a prefix.
///
/// This is `event.` for historic reasons, we should consider switching this to `profile.`.
const PROFIL_GETTER_PREFIX: &str = "event.";

/// Unique identifier for a profile.
///
/// Same format as event IDs.
pub type ProfileId = EventId;

/// Determines the type/use of a [`ProfileChunk`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProfileType {
    /// A backend profile.
    Backend,
    /// A UI profile.
    Ui,
}

impl ProfileType {
    /// Converts a platform to a [`ProfileType`].
    ///
    /// The profile type is currently determined based on the contained profile
    /// platform. It determines the data category this profile chunk belongs to.
    ///
    /// This needs to be synchronized with the implementation in Sentry:
    /// <https://github.com/getsentry/sentry/blob/ed2e1c8bcd0d633e6f828fcfbeefbbdd98ef3dba/src/sentry/profiles/task.py#L995>
    pub fn from_platform(platform: &str) -> Self {
        match platform {
            "cocoa" | "android" | "javascript" => Self::Ui,
            _ => Self::Backend,
        }
    }
}

#[derive(Debug, serde::Deserialize)]
struct MinimalProfile {
    #[serde(alias = "profile_id", alias = "chunk_id")]
    event_id: ProfileId,
    platform: String,
    release: Option<String>,
    #[serde(default)]
    version: sample::Version,
}

impl MinimalProfile {
    fn parse(payload: &[u8]) -> Result<Self, serde_path_to_error::Error<serde_json::Error>> {
        let d = &mut serde_json::Deserializer::from_slice(payload);
        serde_path_to_error::deserialize(d)
    }
}

impl relay_filter::Filterable for MinimalProfile {
    fn release(&self) -> Option<&str> {
        self.release.as_deref()
    }
}

impl relay_protocol::Getter for MinimalProfile {
    fn get_value(&self, path: &str) -> Option<relay_protocol::Val<'_>> {
        match path.strip_prefix("event.")? {
            "release" => self.release.as_deref().map(|release| release.into()),
            "platform" => Some(self.platform.as_str().into()),
            _ => None,
        }
    }
}

/// Parsed profile metadata returned from [`parse_metadata`].
#[derive(Debug)]
pub struct ProfileMetadata {
    pub id: ProfileId,
    pub platform: String,
}

impl ProfileMetadata {
    /// Returns the [`ProfileType`] of the profile.
    ///
    /// The [`ProfileType`] is inferred from the platform.
    pub fn profile_type(&self) -> ProfileType {
        ProfileType::from_platform(&self.platform)
    }
}

pub fn parse_metadata(payload: &[u8]) -> Result<ProfileMetadata, ProfileError> {
    let profile = match MinimalProfile::parse(payload) {
        Ok(profile) => profile,
        Err(err) => {
            relay_log::debug!(
                error = &err as &dyn Error,
                from = "minimal",
                "invalid profile"
            );
            return Err(ProfileError::InvalidJson(err));
        }
    };
    match profile.version {
        sample::Version::V1 => {
            let d = &mut Deserializer::from_slice(payload);
            let _: sample::v1::ProfileMetadata = match serde_path_to_error::deserialize(d) {
                Ok(profile) => profile,
                Err(err) => {
                    relay_log::debug!(
                        error = &err as &dyn Error,
                        from = "metadata",
                        platform = profile.platform,
                        "invalid profile",
                    );
                    return Err(ProfileError::InvalidJson(err));
                }
            };
        }
        _ => match profile.platform.as_str() {
            "android" => {
                let d = &mut Deserializer::from_slice(payload);
                let _: android::legacy::ProfileMetadata = match serde_path_to_error::deserialize(d)
                {
                    Ok(profile) => profile,
                    Err(err) => {
                        relay_log::debug!(
                            error = &err as &dyn Error,
                            from = "metadata",
                            platform = "android",
                            "invalid profile",
                        );
                        return Err(ProfileError::InvalidJson(err));
                    }
                };
            }
            _ => return Err(ProfileError::PlatformNotSupported),
        },
    };

    Ok(ProfileMetadata {
        id: profile.event_id,
        platform: profile.platform,
    })
}

pub fn expand_profile(
    payload: &[u8],
    event: &Event,
    client_ip: Option<IpAddr>,
    filter_settings: &ProjectFiltersConfig,
    global_config: &GlobalConfig,
) -> Result<(ProfileId, Vec<u8>), ProfileError> {
    let profile = match MinimalProfile::parse(payload) {
        Ok(profile) => profile,
        Err(err) => {
            relay_log::debug!(
                error = &err as &dyn Error,
                from = "minimal",
                platform = event.platform.as_str(),
                project_id = event.project.value().unwrap_or(&0),
                sdk_name = event.sdk_name(),
                sdk_version = event.sdk_version(),
                transaction_id = ?event.id.value(),
                "invalid profile",
            );
            return Err(ProfileError::InvalidJson(err));
        }
    };

    if let Err(filter_stat_key) = relay_filter::should_filter(
        &profile,
        client_ip,
        filter_settings,
        global_config.filters(),
    ) {
        return Err(ProfileError::Filtered(filter_stat_key));
    }

    let transaction_metadata = extract_transaction_metadata(event);
    let transaction_tags = extract_transaction_tags(event);
    let processed_payload = match (profile.platform.as_str(), profile.version) {
        (_, sample::Version::V1) => {
            sample::v1::parse_sample_profile(payload, transaction_metadata, transaction_tags)
        }
        ("android", _) => {
            android::legacy::parse_android_profile(payload, transaction_metadata, transaction_tags)
        }
        (_, _) => return Err(ProfileError::PlatformNotSupported),
    };
    match processed_payload {
        Ok(payload) => Ok((profile.event_id, payload)),
        Err(err) => match err {
            ProfileError::InvalidJson(err) => {
                relay_log::debug!(
                    error = &err as &dyn Error,
                    from = "parsing",
                    platform = profile.platform,
                    project_id = event.project.value().unwrap_or(&0),
                    sdk_name = event.sdk_name(),
                    sdk_version = event.sdk_version(),
                    transaction_id = ?event.id.value(),
                    "invalid profile",
                );
                Err(ProfileError::InvalidJson(err))
            }
            _ => {
                relay_log::debug!(
                    error = &err as &dyn Error,
                    from = "parsing",
                    platform = profile.platform,
                    project_id = event.project.value().unwrap_or(&0),
                    sdk_name = event.sdk_name(),
                    sdk_version = event.sdk_version(),
                    transaction_id = ?event.id.value(),
                    "invalid profile",
                );
                Err(err)
            }
        },
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_minimal_profile_with_version() {
        let data = r#"{"version":"1","platform":"cocoa","event_id":"751fff80-a266-467b-a6f5-eeeef65f4f84"}"#;
        let profile = MinimalProfile::parse(data.as_bytes());
        assert!(profile.is_ok());
        assert_eq!(profile.unwrap().version, sample::Version::V1);
    }

    #[test]
    fn test_minimal_profile_without_version() {
        let data = r#"{"platform":"android","event_id":"751fff80-a266-467b-a6f5-eeeef65f4f84"}"#;
        let profile = MinimalProfile::parse(data.as_bytes());
        assert!(profile.is_ok());
        assert_eq!(profile.unwrap().version, sample::Version::Unknown);
    }

    #[test]
    fn test_expand_profile_with_version() {
        let payload = include_bytes!("../tests/fixtures/sample/v1/valid.json");
        assert!(
            expand_profile(
                payload,
                &Event::default(),
                None,
                &ProjectFiltersConfig::default(),
                &GlobalConfig::default()
            )
            .is_ok()
        );
    }

    #[test]
    fn test_expand_profile_with_version_and_segment_id() {
        let payload = include_bytes!("../tests/fixtures/sample/v1/segment_id.json");
        assert!(
            expand_profile(
                payload,
                &Event::default(),
                None,
                &ProjectFiltersConfig::default(),
                &GlobalConfig::default()
            )
            .is_ok()
        );
    }

    #[test]
    fn test_expand_profile_without_version() {
        let payload = include_bytes!("../tests/fixtures/android/legacy/roundtrip.json");
        assert!(
            expand_profile(
                payload,
                &Event::default(),
                None,
                &ProjectFiltersConfig::default(),
                &GlobalConfig::default()
            )
            .is_ok()
        );
    }
}