ref(relay): Migrate to Rust Edition 2024 (#4705)

Mostly done by hand:

- `#[no_mangle]` -> `#[unsafe(no_mangle)]`
- `unsafe fn foo { ... some_unsafe_code() }` -> `unsafe fn foo { ...
unsafe { some_unsafe_code() } }` (mostly in FFI)
- `env::*` is unsafe now, just put them into an unsafe block for now,
this was already in 2021 unsafe, just not marked as such
- `Foo(ref mut bar)` -> `Foo(bar)` (a lot of those)
- Updated `cbindgen` (old version produced edition incompatible code)

Author: Dav1dde

CHANGELOG.md

@@ -17,6 +17,7 @@
 **Internal**:
 
 - Remove threads with 1 non-idle sample in profiling chunks. ([#4694](https://github.com/getsentry/relay/pull/4694))
+- Migrate all Rust workspace crates to edition 2024. ([#4705](https://github.com/getsentry/relay/pull/4705))
 
 ## 25.4.0
 

Cargo.lock

@@ -80,7 +80,7 @@ axum-server = "0.7.1"
 arc-swap = "1.7.1"
 async-trait = "0.1.83"
 backoff = "0.4.0"
-bindgen = "0.70.1"
+bindgen = "0.71.1"
 brotli = "6.0.0"
 bytecount = "0.6.8"
 bytes = "1.10.1"

Cargo.toml

@@ -5,7 +5,7 @@ description = "Authentication and crypto for Relay"
 homepage = "https://getsentry.github.io/relay/"
 repository = "https://github.com/getsentry/relay"
 version = "25.4.0"
-edition = "2021"
+edition = "2024"
 license-file = "../LICENSE.md"
 publish = false
 build = "build.rs"

relay-auth/Cargo.toml

@@ -30,7 +30,7 @@ use data_encoding::BASE64URL_NOPAD;
 use ed25519_dalek::{Signer, Verifier};
 use hmac::{Hmac, Mac};
 use rand::rngs::OsRng;
-use rand::{thread_rng, RngCore};
+use rand::{RngCore, thread_rng};
 use relay_common::time::UnixTimestamp;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
@@ -706,9 +706,9 @@ mod tests {
             "OvXFVm1tIUi8xDTuyHX1SSqdMc8nCt2qU9IUaH5p7oU"
         );
         assert_eq!(
-        format!("{sk:#}"),
-        "OvXFVm1tIUi8xDTuyHX1SSqdMc8nCt2qU9IUaH5p7oUk5pHZsdnfXNiMWiMLtSE86J3N9Peo5CBP1YQHDUkApQ"
-    );
+            format!("{sk:#}"),
+            "OvXFVm1tIUi8xDTuyHX1SSqdMc8nCt2qU9IUaH5p7oUk5pHZsdnfXNiMWiMLtSE86J3N9Peo5CBP1YQHDUkApQ"
+        );
         assert_eq!(
             pk.to_string(),
             "JOaR2bHZ31zYjFojC7UhPOidzfT3qOQgT9WEBw1JAKU"
@@ -755,8 +755,7 @@ mod tests {
         let sig = sk.sign(data);
         assert!(pk.verify(data, &sig));
 
-        let bad_sig =
-        "jgubwSf2wb2wuiRpgt2H9_bdDSMr88hXLp5zVuhbr65EGkSxOfT5ILIWr623twLgLd0bDgHg6xzOaUCX7XvUCw";
+        let bad_sig = "jgubwSf2wb2wuiRpgt2H9_bdDSMr88hXLp5zVuhbr65EGkSxOfT5ILIWr623twLgLd0bDgHg6xzOaUCX7XvUCw";
         assert!(!pk.verify(data, bad_sig));
     }
 

relay-auth/src/lib.rs

@@ -5,7 +5,7 @@ description = "Basic types for Relay's API schema used across multiple services"
 homepage = "https://getsentry.github.io/relay/"
 repository = "https://github.com/getsentry/relay"
 version = "25.4.0"
-edition = "2021"
+edition = "2024"
 license-file = "../LICENSE.md"
 publish = false
 

relay-base-schema/Cargo.toml

@@ -463,9 +463,7 @@ mod tests {
     fn test_normalize_name_length() {
         let long_mri = "c:custom/ThisIsACharacterLongStringForTestingPurposesToEnsureThatWeHaveEnoughCharactersToWorkWithAndToCheckIfOurFunctionProperlyHandlesSlicingAndNormalizationWithoutErrors";
         assert_eq!(
-            MetricResourceIdentifier::parse(long_mri)
-                .unwrap()
-                .name,
+            MetricResourceIdentifier::parse(long_mri).unwrap().name,
             "ThisIsACharacterLongStringForTestingPurposesToEnsureThatWeHaveEnoughCharactersToWorkWithAndToCheckIfOurFunctionProperlyHandlesSlicingAndNormalizationW"
         );
 

relay-base-schema/src/metrics/mri.rs

@@ -5,7 +5,7 @@ authors = ["Sentry <[email protected]>"]
 homepage = "https://getsentry.github.io/relay/"
 repository = "https://github.com/getsentry/relay"
 description = "Exposes some internals of the relay to C."
-edition = "2021"
+edition = "2024"
 license-file = "../LICENSE.md"
 publish = false
 

relay-cabi/Cargo.toml

@@ -1,7 +1,7 @@
 use chrono::Duration;
 use relay_auth::{
-    generate_key_pair, generate_relay_id, PublicKey, RegisterRequest, RegisterResponse, RelayId,
-    RelayVersion, SecretKey,
+    PublicKey, RegisterRequest, RegisterResponse, RelayId, RelayVersion, SecretKey,
+    generate_key_pair, generate_relay_id,
 };
 use serde::Serialize;
 
@@ -26,45 +26,45 @@ pub struct RelayKeyPair {
 pub struct RelayRegisterRequest;
 
 /// Parses a public key from a string.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_publickey_parse(s: *const RelayStr) -> *mut RelayPublicKey {
-    let public_key: PublicKey = (*s).as_str().parse()?;
+    let public_key: PublicKey = unsafe { (*s).as_str() }.parse()?;
     Box::into_raw(Box::new(public_key)) as *mut RelayPublicKey
 }
 
 /// Frees a public key.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_publickey_free(spk: *mut RelayPublicKey) {
     if !spk.is_null() {
         let pk = spk as *mut PublicKey;
-        let _dropped = Box::from_raw(pk);
+        let _dropped = unsafe { Box::from_raw(pk) };
     }
 }
 
 /// Converts a public key into a string.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_publickey_to_string(spk: *const RelayPublicKey) -> RelayStr {
     let pk = spk as *const PublicKey;
-    RelayStr::from_string((*pk).to_string())
+    unsafe { RelayStr::from_string((*pk).to_string()) }
 }
 
 /// Verifies a signature
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_publickey_verify(
     spk: *const RelayPublicKey,
     data: *const RelayBuf,
     sig: *const RelayStr,
 ) -> bool {
     let pk = spk as *const PublicKey;
-    (*pk).verify((*data).as_bytes(), (*sig).as_str())
+    unsafe { (*pk).verify((*data).as_bytes(), (*sig).as_str()) }
 }
 
 /// Verifies a signature
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_publickey_verify_timestamp(
     spk: *const RelayPublicKey,
@@ -74,48 +74,48 @@ pub unsafe extern "C" fn relay_publickey_verify_timestamp(
 ) -> bool {
     let pk = spk as *const PublicKey;
     let max_age = Some(Duration::seconds(i64::from(max_age)));
-    (*pk).verify_timestamp((*data).as_bytes(), (*sig).as_str(), max_age)
+    unsafe { (*pk).verify_timestamp((*data).as_bytes(), (*sig).as_str(), max_age) }
 }
 
 /// Parses a secret key from a string.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_secretkey_parse(s: &RelayStr) -> *mut RelaySecretKey {
-    let secret_key: SecretKey = s.as_str().parse()?;
+    let secret_key: SecretKey = unsafe { s.as_str() }.parse()?;
     Box::into_raw(Box::new(secret_key)) as *mut RelaySecretKey
 }
 
 /// Frees a secret key.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_secretkey_free(spk: *mut RelaySecretKey) {
     if !spk.is_null() {
         let pk = spk as *mut SecretKey;
-        let _dropped = Box::from_raw(pk);
+        let _dropped = unsafe { Box::from_raw(pk) };
     }
 }
 
 /// Converts a secret key into a string.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_secretkey_to_string(spk: *const RelaySecretKey) -> RelayStr {
     let pk = spk as *const SecretKey;
-    RelayStr::from_string((*pk).to_string())
+    unsafe { RelayStr::from_string((*pk).to_string()) }
 }
 
 /// Verifies a signature
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_secretkey_sign(
     spk: *const RelaySecretKey,
     data: *const RelayBuf,
 ) -> RelayStr {
     let pk = spk as *const SecretKey;
-    RelayStr::from_string((*pk).sign((*data).as_bytes()))
+    unsafe { RelayStr::from_string((*pk).sign((*data).as_bytes())) }
 }
 
 /// Generates a secret, public key pair.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_generate_key_pair() -> RelayKeyPair {
     let (sk, pk) = generate_key_pair();
@@ -126,15 +126,15 @@ pub unsafe extern "C" fn relay_generate_key_pair() -> RelayKeyPair {
 }
 
 /// Randomly generates an relay id
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_generate_relay_id() -> RelayUuid {
     let relay_id = generate_relay_id();
     RelayUuid::new(relay_id)
 }
 
 /// Creates a challenge from a register request and returns JSON.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_create_register_challenge(
     data: *const RelayBuf,
@@ -147,10 +147,13 @@ pub unsafe extern "C" fn relay_create_register_challenge(
         m => Some(Duration::seconds(i64::from(m))),
     };
 
-    let req =
-        RegisterRequest::bootstrap_unpack((*data).as_bytes(), (*signature).as_str(), max_age)?;
+    let challenge = unsafe {
+        let req =
+            RegisterRequest::bootstrap_unpack((*data).as_bytes(), (*signature).as_str(), max_age)?;
+
+        req.into_challenge((*secret).as_str().as_bytes())
+    };
 
-    let challenge = req.into_challenge((*secret).as_str().as_bytes());
     RelayStr::from_string(serde_json::to_string(&challenge)?)
 }
 
@@ -163,7 +166,7 @@ struct RelayRegisterResponse<'a> {
 }
 
 /// Validates a register response.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_validate_register_response(
     data: *const RelayBuf,
@@ -177,9 +180,9 @@ pub unsafe extern "C" fn relay_validate_register_response(
     };
 
     let (response, state) = RegisterResponse::unpack(
-        (*data).as_bytes(),
-        (*signature).as_str(),
-        (*secret).as_str().as_bytes(),
+        unsafe { (*data).as_bytes() },
+        unsafe { (*signature).as_str() },
+        unsafe { (*secret).as_str().as_bytes() },
         max_age,
     )?;
 
@@ -195,10 +198,10 @@ pub unsafe extern "C" fn relay_validate_register_response(
 }
 
 /// Returns true if the given version is supported by this library.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_version_supported(version: &RelayStr) -> bool {
-    let relay_version = match version.as_str() {
+    let relay_version = match unsafe { version.as_str() } {
         "" => RelayVersion::default(),
         s => s.parse::<RelayVersion>()?,
     };

relay-cabi/src/auth.rs

@@ -95,14 +95,14 @@ fn translate_codeowners_pattern(pattern: &str) -> Option<Regex> {
 }
 
 /// Returns `true` if the codeowners path matches the value, `false` otherwise.
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[relay_ffi::catch_unwind]
 pub unsafe extern "C" fn relay_is_codeowners_path_match(
     value: *const RelayBuf,
     pattern: *const RelayStr,
 ) -> bool {
-    let value = (*value).as_bytes();
-    let pat = (*pattern).as_str();
+    let value = unsafe { (*value).as_bytes() };
+    let pat = unsafe { (*pattern).as_str() };
 
     let mut cache = CODEOWNERS_CACHE.lock().unwrap();