Remove some tracing

minecraft-server/src/entities/entity.rs

@@ -31,8 +31,6 @@ pub struct Entity {
 }
 
 impl Handler<Entity> {
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
     pub async fn init(self, server_msg_rcvr: BroadcastReceiver<ServerMessage>) {
         self.insert_task("newton", tokio::spawn(newton_task(self.clone(), server_msg_rcvr))).await;
     }

minecraft-server/src/main.rs

@@ -23,7 +23,7 @@ impl std::future::Future for ServerFuture {
 
 #[tokio::main]
 async fn main() {
-    #[cfg(feature = "tracing")]
+    #[cfg(feature = "trace")]
     #[global_allocator]
     static GLOBAL: tracy_client::ProfiledAllocator<std::alloc::System> =
         tracy_client::ProfiledAllocator::new(std::alloc::System, 100);
@@ -32,7 +32,7 @@ async fn main() {
 
     let subscriber = Registry::default()
                                 .with(fmt::layer());
-    #[cfg(feature = "tracing")]
+    #[cfg(feature = "trace")]
     let subscriber = subscriber
         .with(tracing_tracy::TracyLayer::new());
 

minecraft-server/src/player_handler/login.rs

@@ -6,8 +6,7 @@ pub struct LoggedInPlayerInfo {
     pub(super) uuid: u128,
 }
 
-#[cfg_attr(feature = "tracing", instrument(skip_all))]
-
+#[cfg_attr(feature = "trace", instrument(skip_all))]
 pub async fn login(stream: &mut TcpStream, addr: SocketAddr) -> Result<LoggedInPlayerInfo, ()> {
     // Receive login start
     let packet = receive_packet(stream).await?;

minecraft-server/src/player_handler/network.rs

@@ -48,23 +48,23 @@ pub async fn receive_packet_split(stream: &mut OwnedReadHalf) -> Result<Vec<u8>,
     Ok(data)
 }
 
-#[cfg_attr(feature = "tracing", instrument)]
+#[cfg_attr(feature = "trace", instrument)]
 pub async fn send_packet_raw(stream: &mut TcpStream, packet: &[u8]) {
     let length = VarInt::from(packet.len());
     stream.write_all(length.serialize_minecraft_packet().unwrap().as_slice()).await.unwrap();
     stream.write_all(packet).await.unwrap();
     stream.flush().await.unwrap();
 }
 
-#[cfg_attr(feature = "tracing", instrument)]
+#[cfg_attr(feature = "trace", instrument)]
 pub async fn send_packet_raw_split(stream: &mut OwnedWriteHalf, packet: &[u8]) {
     let length = VarInt::from(packet.len());
     stream.write_all(length.serialize_minecraft_packet().unwrap().as_slice()).await.unwrap();
     stream.write_all(packet).await.unwrap();
     stream.flush().await.unwrap();
 }
 
-#[cfg_attr(feature = "tracing", instrument(skip_all))]
+#[cfg_attr(feature = "trace", instrument(skip_all))]
 pub async fn send_packet<'a, P: MinecraftPacketPart<'a>>(stream: &mut TcpStream, packet: P) {
     let packet = packet.serialize_minecraft_packet().unwrap();
     send_packet_raw(stream, packet.as_slice()).await;

minecraft-server/src/player_handler/status.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-#[cfg_attr(feature = "tracing", instrument(skip_all))]
+#[cfg_attr(feature = "trace", instrument(skip_all))]
 pub async fn status(stream: &mut TcpStream) -> Result<(), ()> {
     loop {
         let packet = receive_packet(stream).await?;

minecraft-server/src/world/ecs.rs

@@ -31,16 +31,12 @@ impl Entities {
     }
 
     /// Observe an entity through a closure
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
     pub(super) async fn observe_entity<R>(&self, eid: Eid, observer: impl FnOnce(&AnyEntity) -> R) -> Option<R> {
         self.entities.read().await.get(&eid).map(observer)
     }
 
     /// Observe entities in a chunk through a closure
     /// That closure will be applied to each entity, and the results will be returned in a vector
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
     pub(super) async fn observe_entities<R>(&self, chunk: ChunkColumnPosition, mut observer: impl FnMut(&AnyEntity) -> Option<R>) -> Vec<R> {
         let entities = self.entities.read().await;
         let chunks = self.chunks.read().await;
@@ -57,8 +53,6 @@ impl Entities {
     }
 
     /// Mutate an entity through a closure
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
     pub(super) async fn mutate_entity<R>(&self, eid: Eid, mutator: impl FnOnce(&mut AnyEntity) -> (R, EntityChanges)) -> Option<(R, EntityChanges)> {
         let mut entities = self.entities.write().await;
 
@@ -79,8 +73,7 @@ impl Entities {
         }
     }
 
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
+    #[cfg_attr(feature = "trace", instrument(skip_all))]
     pub(super) async fn spawn_entity<E>(&self, entity: AnyEntity, world: &'static World, receiver: BroadcastReceiver<ServerMessage>) -> (Eid, UUID)
         where AnyEntity: TryAsEntityRef<E>, Handler<E>: EntityExt
     {
@@ -100,8 +93,6 @@ impl Entities {
         (eid, uuid)
     }
 
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
     pub(super) async fn insert_entity_task(&self, eid: Eid, name: &'static str, handle: EntityTaskHandle) {
         let mut entity_tasks = self.entity_tasks.write().await;
         let old = entity_tasks.entry(eid).or_insert(HashMap::new()).insert(name, handle);
@@ -111,8 +102,7 @@ impl Entities {
     }
 
     /// Remove an entity
-    #[cfg_attr(feature = "tracing", instrument(skip_all))]
-
+    #[cfg_attr(feature = "trace", instrument(skip_all))]
     pub(super) async fn remove_entity(&self, eid: Eid) -> Option<AnyEntity> {
         let entity = self.entities.write().await.remove(&eid);
         let mut chunks = self.chunks.write().await;