Use Base Debug

Expand MatchmakeSessionSearchCriteria and Add Deserializing Logs
feat(ci): Better Job Names
2026-08-08 16:42:08 +01:00 · 2026-08-08 16:42:08 +01:00 · 2026-08-08 16:42:08 +01:00 · 2026-08-08 16:29:57 +02:00 · 2026-08-08 16:28:11 +02:00 · 2026-08-08 16:22:33 +02:00
4 changed files with 364 additions and 35 deletions
--- a/.forgejo/workflows/build.yml
+++ b/.forgejo/workflows/build.yml
@ -31,6 +31,8 @@ jobs:
          - edition: super-mario-maker
            db_secret: DATABASE_SMM
          - edition: terraria
+    
+    name: ${{ matrix.edition }}

    steps:
      - name: Checkout repository
--- a/rnex-protocols/mm-protos/src/matchmake.rs
+++ b/rnex-protocols/mm-protos/src/matchmake.rs
@ -9,6 +9,7 @@ use rnex_rmc::{
    util::{PID, station_url::StationUrl},
    variant::Variant,
 };
+use tracing::info;

 #[derive(RmcSerialize, Debug, Clone, Default, PartialEq)]
 #[rmc_struct(0)]
@ -77,24 +78,363 @@ cfg_if! {
    }
 }

-#[derive(RmcSerialize, Debug, Clone)]
-#[rmc_struct(3)]
+#[derive(Debug)]
 pub struct MatchmakeSessionSearchCriteria {
-    pub attribs: Vec<StringSet<u32>>,
-    pub game_mode: String,
-    pub minimum_participants: String,
-    pub maximum_participants: String,
-    pub matchmake_system_type: String,
-    pub vacant_only: bool,
-    pub exclude_locked: bool,
-    pub exclude_non_host_pid: bool,
-    pub selection_method: u32,
-    pub vacant_participants: u16,
-    pub matchmake_param: MatchmakeParam,
-    pub exclude_user_password_set: bool,
-    pub exclude_system_password_set: bool,
-    pub refer_gid: u32,
-}
+        pub attribs: Vec<StringSet<u32>>,
+        pub game_mode: String,
+        pub minimum_participants: String,
+        pub maximum_participants: String,
+        pub matchmake_system_type: String,
+        pub vacant_only: bool,
+        pub exclude_locked: bool,
+        pub exclude_non_host_pid: bool,
+        pub selection_method: u32,
+        pub vacant_participants: u16,
+        pub matchmake_param: MatchmakeParam,
+        pub exclude_user_password_set: bool,
+        pub exclude_system_password_set: bool,
+        pub refer_gid: u32,
+    }
+    #[automatically_derived]
+    impl ::rnex_rmc::serialization::RmcSerialize for MatchmakeSessionSearchCriteria {
+        #[inline(always)]
+        fn serialize(
+            &self,
+            writer: &mut (impl ::std::io::Write + ?::std::marker::Sized),
+        ) -> ::rnex_rmc::serialization::Result<()> {
+            ::rnex_rmc::rmc_struct::write_struct(
+                writer,
+                Self::version().unwrap(),
+                ::rnex_rmc::helpers::len_of_write(|writer| {
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.attribs,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.game_mode,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.minimum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.maximum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_system_type,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_only,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_locked,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_non_host_pid,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.selection_method,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_param,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_user_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_system_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.refer_gid,
+                        writer,
+                    )?;
+                    Ok(())
+                }),
+                |writer| {
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.attribs,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.game_mode,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.minimum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.maximum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_system_type,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_only,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_locked,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_non_host_pid,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.selection_method,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_param,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_user_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_system_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.refer_gid,
+                        writer,
+                    )?;
+                    Ok(())
+                },
+            )?;
+            Ok(())
+        }
+        #[inline(always)]
+        fn deserialize(
+            reader: &mut (impl ::std::io::Read + ?::std::marker::Sized),
+        ) -> ::rnex_rmc::serialization::Result<Self> {
+            ::rnex_rmc::rmc_struct::read_struct(
+                reader,
+                Self::version().unwrap(),
+                move |mut reader| {
+                    info!("Deserializing attribs in MatchmakeSessionSearchCriteria");
+                    let attribs: Vec<StringSet<u32>> = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("attribs: {:?}", attribs);
+                    info!("Deserializing game_mode in MatchmakeSessionSearchCriteria");
+                    let game_mode: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("game_mode: {}", game_mode);
+                    info!("Deserializing minimum_participants in MatchmakeSessionSearchCriteria");
+                    let minimum_participants: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("minimum_participants: {}", minimum_participants);
+                    info!("Deserializing maximum_participants in MatchmakeSessionSearchCriteria");
+                    let maximum_participants: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("maximum_participants: {}", maximum_participants);
+                    info!("Deserializing matchmake_system_type in MatchmakeSessionSearchCriteria");
+                    let matchmake_system_type: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("matchmake_system_type: {}", matchmake_system_type);
+                    info!("Deserializing vacant_only in MatchmakeSessionSearchCriteria");
+                    let vacant_only: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("vacant_only: {}", vacant_only);
+                    info!("Deserializing exclude_locked in MatchmakeSessionSearchCriteria");
+                    let exclude_locked: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_locked: {}", exclude_locked);
+                    info!("Deserializing exclude_non_host_pid in MatchmakeSessionSearchCriteria");
+                    let exclude_non_host_pid: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_non_host_pid: {}", exclude_non_host_pid);
+                    info!("Deserializing selection_method in MatchmakeSessionSearchCriteria");
+                    let selection_method: u32 = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("selection_method: {}", selection_method);
+                    info!("Deserializing vacant_participants in MatchmakeSessionSearchCriteria");
+                    let vacant_participants: u16 = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("vacant_participants: {}", vacant_participants);
+                    info!("Deserializing matchmake_param in MatchmakeSessionSearchCriteria");
+                    let matchmake_param: MatchmakeParam = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("matchmake_param: {:?}", matchmake_param);
+                    info!("Deserializing exclude_user_password_set in MatchmakeSessionSearchCriteria");
+                    let exclude_user_password_set: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_user_password_set: {}", exclude_user_password_set);
+                    info!("Deserializing exclude_system_password_set in MatchmakeSessionSearchCriteria");
+                    let exclude_system_password_set: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_system_password_set: {}", exclude_system_password_set);
+                    info!("Deserializing refer_gid in MatchmakeSessionSearchCriteria");
+                    let refer_gid: u32 = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("refer_gid: {}", refer_gid);
+                    info!("MatchmakeSessionSearchCriteria deserialized, returning data");
+                    Ok(Self {
+                        attribs,
+                        game_mode,
+                        minimum_participants,
+                        maximum_participants,
+                        matchmake_system_type,
+                        vacant_only,
+                        exclude_locked,
+                        exclude_non_host_pid,
+                        selection_method,
+                        vacant_participants,
+                        matchmake_param,
+                        exclude_user_password_set,
+                        exclude_system_password_set,
+                        refer_gid,
+                    })
+                },
+            )
+        }
+        fn serialize_write_size(&self) -> ::rnex_rmc::serialization::Result<u32> {
+            let mut sum = 0;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.attribs,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.game_mode,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.minimum_participants,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.maximum_participants,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.matchmake_system_type,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.vacant_only,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_locked,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_non_host_pid,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.selection_method,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.vacant_participants,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.matchmake_param,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_user_password_set,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_system_password_set,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.refer_gid,
+                )?;
+            let sum = sum
+                + (if ::rnex_rmc::config::FEATURE_HAS_STRUCT_HEADER { 5 } else { 0 });
+            Ok(sum)
+        }
+        fn version() -> Option<u8> {
+            Some({ 3 })
+        }
+    }
+    impl ::rnex_rmc::serialization::RmcStruct for MatchmakeSessionSearchCriteria {
+        fn get_struct_info() -> &'static ::rnex_rmc::serialization::RmcStructInfo {
+            static STRUCT_DATA: ::rnex_rmc::serialization::RmcStructInfo = ::rnex_rmc::serialization::RmcStructInfo {
+                inheritors: ::std::sync::RwLock::new(::std::vec::Vec::new()),
+                name: "MatchmakeSessionSearchCriteria",
+            };
+            &STRUCT_DATA
+        }
+    }
+    #[automatically_derived]
+    impl ::core::clone::Clone for MatchmakeSessionSearchCriteria {
+        #[inline]
+        fn clone(&self) -> MatchmakeSessionSearchCriteria {
+            MatchmakeSessionSearchCriteria {
+                attribs: ::core::clone::Clone::clone(&self.attribs),
+                game_mode: ::core::clone::Clone::clone(&self.game_mode),
+                minimum_participants: ::core::clone::Clone::clone(
+                    &self.minimum_participants,
+                ),
+                maximum_participants: ::core::clone::Clone::clone(
+                    &self.maximum_participants,
+                ),
+                matchmake_system_type: ::core::clone::Clone::clone(
+                    &self.matchmake_system_type,
+                ),
+                vacant_only: ::core::clone::Clone::clone(&self.vacant_only),
+                exclude_locked: ::core::clone::Clone::clone(&self.exclude_locked),
+                exclude_non_host_pid: ::core::clone::Clone::clone(
+                    &self.exclude_non_host_pid,
+                ),
+                selection_method: ::core::clone::Clone::clone(&self.selection_method),
+                vacant_participants: ::core::clone::Clone::clone(
+                    &self.vacant_participants,
+                ),
+                matchmake_param: ::core::clone::Clone::clone(&self.matchmake_param),
+                exclude_user_password_set: ::core::clone::Clone::clone(
+                    &self.exclude_user_password_set,
+                ),
+                exclude_system_password_set: ::core::clone::Clone::clone(
+                    &self.exclude_system_password_set,
+                ),
+                refer_gid: ::core::clone::Clone::clone(&self.refer_gid),
+            }
+        }
+    }

 #[derive(RmcSerialize, Debug, Clone)]
 #[rmc_struct(0)]
--- a/rnex-protocols/mm-protos/src/matchmake_extension.rs
+++ b/rnex-protocols/mm-protos/src/matchmake_extension.rs
@ -20,7 +20,7 @@ pub trait MatchmakeExtension {
    #[method_id(4)]
    async fn browse_matchmake_session(
        &self,
-        borwse_criteria: MatchmakeSessionSearchCriteria,
+        browse_criteria: MatchmakeSessionSearchCriteria,
        result_range: ResultsRange,
    ) -> Result<Vec<Any<Gathering>>, ErrorCode>;
    #[method_id(6)]
--- a/rnex-rmc/src/lib.rs
+++ b/rnex-rmc/src/lib.rs
@ -38,7 +38,7 @@ pub mod config {

 pub use paste;
 pub use rnex_util as util;
-use tracing::{Instrument, error, info, info_span, instrument};
+use tracing::{error, info, info_span};

 use crate::{
    RemoteCallError::ConnectionBroke,
@ -322,7 +322,6 @@ impl<T: RemoteDisconnectable> RmcCallable for OnlyRemote<T> {
    }
 }

-#[instrument]
 async fn handle_incoming<T: RmcCallable + Send + Sync + Debug + 'static>(
    sending_conn: SendingBufferConnection,
    remote: Arc<T>,
@ -391,18 +390,10 @@ async fn handle_incoming<T: RmcCallable + Send + Sync + Debug + 'static>(
                )
            }
        }
-        .instrument(info_span!(
-            "rmc call",
-            protocol_id,
-            method_id,
-            call_id,
-            raw_arguments = hex::encode(&rest_of_data),
-        ))
        .await;
    }
 }

-#[instrument]
 async fn handle_incoming_loop<T: RmcCallable + Send + Sync + Debug + 'static>(
    mut connection: SplittableBufferConnection,
    remote: Arc<T>,
@ -415,7 +406,7 @@ async fn handle_incoming_loop<T: RmcCallable + Send + Sync + Debug + 'static>(
        let notify = notify.clone();
        let incoming = incoming.clone();
        task::spawn(
-            handle_incoming(sending_conn, remote, notify, incoming, data).in_current_span(),
+            handle_incoming(sending_conn, remote, notify, incoming, data),
        );
    }

@ -441,9 +432,7 @@ where

        let sending_conn = conn.duplicate_sender();

-        let exposed_object = (create_internal)(rmc_conn)
-            .instrument(info_span!("initializing inner object"))
-            .await;
+        let exposed_object = (create_internal)(rmc_conn).await;

        {
            let exposed_object = exposed_object.clone();
@ -457,15 +446,13 @@ where
                        sending_conn.send([0, 0, 0, 0, 0].to_vec()).await;
                        sleep(Duration::from_secs(10)).await;
                    }
-                }
-                .instrument(info_span!("timeout sender")),
+                },
            );
        }

        exposed_object
    }
    // todo: maybe add info on who we're creating the gateway to somehow
-    .instrument(info_span!("create new rmc gateway connection"))
    .await
 }
Author	SHA1	Message	Date
BloxerHD	c2f692cb14	Use Base Debug All checks were successful Build and Test / friends (push) Successful in 5m9s Details Build and Test / puyopuyo (push) Successful in 4m7s Details Build and Test / wii-sports-club (push) Successful in 4m34s Details Build and Test / wii-u-chat (push) Successful in 4m34s Details Build and Test / splatoon-testfire (push) Successful in 5m20s Details Build and Test / minecraft-wiiu (push) Successful in 5m57s Details Build and Test / mario-tennis (push) Successful in 6m24s Details Build and Test / splatoon (push) Successful in 6m29s Details Build and Test / super-mario-maker (push) Successful in 6m36s Details Build and Test / sonic-transformed (push) Successful in 6m40s Details Build and Test / terraria (push) Successful in 6m52s Details Build and Test / fast-racing-neo (push) Successful in 6m52s Details	2026-08-08 16:42:08 +01:00
BloxerHD	58bd13aae4	Expand MatchmakeSessionSearchCriteria and Add Deserializing Logs	2026-08-08 16:42:08 +01:00
BloxerHD	0d81ed0869	feat(ci): Better Job Names	2026-08-08 16:42:08 +01:00
redbinder0526	8f049397ae	fix(instrument-removal): bruh i forgot All checks were successful Build and Test / build-editions (splatoon) (push) Successful in 3m16s Details Build and Test / build-editions (DATABASE_SMM, puyopuyo) (push) Successful in 5m31s Details Build and Test / build-editions (DATABASE_SMM, super-mario-maker) (push) Successful in 5m32s Details Build and Test / build-editions (DATABASE_SMM, wii-sports-club) (push) Successful in 5m55s Details Build and Test / build-editions (fast-racing-neo) (push) Successful in 5m55s Details Build and Test / build-editions (mario-tennis) (push) Successful in 6m39s Details Build and Test / build-editions (splatoon-testfire) (push) Successful in 6m43s Details Build and Test / build-editions (sonic-transformed) (push) Successful in 5m34s Details Build and Test / build-editions (minecraft-wiiu) (push) Successful in 2m53s Details Build and Test / build-editions (DATABASE_FRIENDS, friends) (push) Successful in 7m24s Details Build and Test / build-editions (wii-u-chat) (push) Successful in 8m23s Details Build and Test / build-editions (terraria) (push) Successful in 8m23s Details	2026-08-08 16:29:57 +02:00
redbinder0526	98712a6051	fix(logs): remove instrument because it was just spamming logs Some checks failed Build and Test / build-editions (minecraft-wiiu) (push) Failing after 40s Details Build and Test / build-editions (mario-tennis) (push) Failing after 51s Details Build and Test / build-editions (fast-racing-neo) (push) Failing after 59s Details Build and Test / build-editions (terraria) (push) Failing after 1m1s Details Build and Test / build-editions (splatoon-testfire) (push) Failing after 1m5s Details Build and Test / build-editions (splatoon) (push) Failing after 1m4s Details Build and Test / build-editions (DATABASE_SMM, super-mario-maker) (push) Failing after 1m12s Details Build and Test / build-editions (DATABASE_SMM, puyopuyo) (push) Failing after 1m12s Details Build and Test / build-editions (DATABASE_SMM, wii-sports-club) (push) Failing after 1m11s Details Build and Test / build-editions (sonic-transformed) (push) Failing after 1m12s Details Build and Test / build-editions (wii-u-chat) (push) Failing after 1m12s Details Build and Test / build-editions (DATABASE_FRIENDS, friends) (push) Failing after 1m14s Details	2026-08-08 16:28:11 +02:00
redbinder0526	4d3cbb9fd6	fix(mm): spelling on criteria Some checks failed Build and Test / build-editions (DATABASE_SMM, super-mario-maker) (push) Successful in 3m50s Details Build and Test / build-editions (minecraft-wiiu) (push) Successful in 4m19s Details Build and Test / build-editions (mario-tennis) (push) Successful in 4m23s Details Build and Test / build-editions (sonic-transformed) (push) Successful in 4m41s Details Build and Test / build-editions (wii-u-chat) (push) Successful in 4m46s Details Build and Test / build-editions (DATABASE_SMM, wii-sports-club) (push) Successful in 4m59s Details Build and Test / build-editions (DATABASE_SMM, puyopuyo) (push) Successful in 5m6s Details Build and Test / build-editions (terraria) (push) Successful in 5m17s Details Build and Test / build-editions (splatoon-testfire) (push) Successful in 5m18s Details Build and Test / build-editions (fast-racing-neo) (push) Successful in 5m19s Details Build and Test / build-editions (splatoon) (push) Successful in 5m26s Details Build and Test / build-editions (DATABASE_FRIENDS, friends) (push) Has been cancelled Details	2026-08-08 16:22:33 +02:00