make tracing optional

Cargo.toml

@@ -43,11 +43,12 @@ no-panic = { version = "0.1", optional = true }
 fnv = "1"
 steamid-ng = "1"
 schemars = { version = "0.8", optional = true }
-tracing = "0.1"
+tracing = { version = "0.1", optional = true }
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter"], optional = true }
 
 [features]
 schema = ["schemars", "bitbuffer/schemars"]
+trace = ["tracing", "tracing-subscriber"]
 
 [dev-dependencies]
 pretty_assertions = "1"

src/bin/main.rs

@@ -12,6 +12,7 @@ fn main() -> Result<(), MainError> {
     #[cfg(feature = "better_panic")]
     better_panic::install();
 
+    #[cfg(feature = "trace")]
     tracing_subscriber::fmt::init();
 
     let args: Vec<_> = env::args().collect();

src/bin/reencode.rs

@@ -23,6 +23,7 @@ const COPY_TYPES: &[PacketType] = &[
 ];
 
 fn main() -> Result<(), MainError> {
+    #[cfg(feature = "trace")]
     tracing_subscriber::fmt::init();
 
     #[cfg(feature = "better_panic")]

src/demo/packet/message.rs

@@ -1,17 +1,18 @@
-use bitbuffer::{bit_size_of, BitRead, BitWrite, BitWriteStream, Endianness, LittleEndian};
+use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
 use serde::{Deserialize, Serialize};
 
 use crate::demo::message::{Message, MessageType};
 use crate::demo::parser::Encode;
 use crate::demo::vector::Vector;
-use crate::{Parse, ParserState, ReadResult, Result, Stream};
+use crate::{Parse, ParserState, Result, Stream};
+#[cfg(feature = "trace")]
 use tracing::{event, span, Level};
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, BitRead, BitWrite, PartialEq, Serialize, Deserialize, Clone, Default)]
 pub struct MessagePacketMeta {
     pub flags: u32, // TODO
-    pub view_angles: ViewAngles,
+    pub view_angles: [ViewAngles; 2],
     pub sequence_in: u32,
     pub sequence_out: u32,
 }
@@ -26,89 +27,32 @@ pub struct MessagePacket<'a> {
 }
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize, BitRead, BitWrite)]
 pub struct ViewAngles {
-    pub origin: (Vector, Vector),
+    pub origin: Vector,
-    pub angles: (Vector, Vector),
+    pub angles: Vector,
-    pub local_angles: (Vector, Vector),
+    pub local_angles: Vector,
-}
-
-impl<E: Endianness> BitRead<'_, E> for ViewAngles {
-    fn read(stream: &mut bitbuffer::BitReadStream<E>) -> ReadResult<Self> {
-        let vectors = <[Vector; 6]>::read(stream)?;
-        let origin = (vectors[3], vectors[0]);
-        let angles = (vectors[4], vectors[1]);
-        let local_angles = (vectors[5], vectors[2]);
-        Ok(ViewAngles {
-            origin,
-            angles,
-            local_angles,
-        })
-    }
-
-    fn bit_size() -> Option<usize> {
-        Some(bit_size_of::<Vector>().unwrap() * 6)
-    }
-}
-
-impl<E: Endianness> BitWrite<E> for ViewAngles {
-    fn write(&self, stream: &mut bitbuffer::BitWriteStream<E>) -> ReadResult<()> {
-        [
-            self.origin.1,
-            self.angles.1,
-            self.local_angles.1,
-            self.origin.0,
-            self.angles.0,
-            self.local_angles.0,
-        ]
-        .write(stream)
-    }
 }
 
 #[test]
 fn test_view_angles_roundtrip() {
+    crate::test_roundtrip_write(ViewAngles::default());
     crate::test_roundtrip_write(ViewAngles {
-        origin: (Vector::default(), Vector::default()),
+        origin: Vector {
-        angles: (Vector::default(), Vector::default()),
+            x: 1.0,
-        local_angles: (Vector::default(), Vector::default()),
+            y: 2.0,
-    });
+            z: 3.0,
-    crate::test_roundtrip_write(ViewAngles {
+        },
-        origin: (
+        angles: Vector {
-            Vector {
+            x: 4.0,
-                x: 1.0,
+            y: 5.0,
-                y: 1.0,
+            z: 6.0,
-                z: 1.0,
+        },
-            },
+        local_angles: Vector {
-            Vector {
+            x: 7.0,
-                x: 2.0,
+            y: 8.0,
-                y: 2.0,
+            z: 9.0,
-                z: 2.0,
+        },
-            },
-        ),
-        angles: (
-            Vector {
-                x: 3.0,
-                y: 3.0,
-                z: 3.0,
-            },
-            Vector {
-                x: 4.0,
-                y: 4.0,
-                z: 4.0,
-            },
-        ),
-        local_angles: (
-            Vector {
-                x: 5.0,
-                y: 5.0,
-                z: 5.0,
-            },
-            Vector {
-                x: 6.0,
-                y: 6.0,
-                z: 6.0,
-            },
-        ),
     });
 }
 
@@ -119,20 +63,23 @@ impl<'a> Parse<'a> for MessagePacket<'a> {
         let meta = stream.read()?;
 
         let length: u32 = stream.read()?;
-        event!(Level::DEBUG, length, "reading packet data");
         let mut packet_data = stream.read_bits(length as usize * 8)?;
 
         let mut messages = Vec::with_capacity(8);
         while packet_data.bits_left() > 6 {
             let message_type = MessageType::read(&mut packet_data)?;
+            #[cfg(feature = "trace")]
             let _span =
-                span!(Level::INFO, "reading packet", message_type = ?message_type).entered();
+                span!(Level::DEBUG, "reading message", message_type = ?message_type, tick = tick)
+                    .entered();
 
             if state.should_parse_message(message_type) && message_type != MessageType::Empty {
-                event!(Level::INFO, "parsing message");
+                #[cfg(feature = "trace")]
+                event!(Level::TRACE, "parsing message");
                 messages.push(Message::from_type(message_type, &mut packet_data, state)?);
             } else {
-                event!(Level::INFO, "skipping message");
+                #[cfg(feature = "trace")]
+                event!(Level::TRACE, "skipping message");
                 Message::skip_type(message_type, &mut packet_data, state)?;
             }
         }

src/demo/packet/mod.rs

@@ -11,6 +11,7 @@ use self::synctick::SyncTickPacket;
 use self::usercmd::UserCmdPacket;
 use crate::demo::parser::Encode;
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "trace")]
 use tracing::{event, span, Level};
 
 pub mod consolecmd;
@@ -97,8 +98,15 @@ impl Packet<'_> {
 impl<'a> Parse<'a> for Packet<'a> {
     fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
         let packet_type = PacketType::read(stream)?;
-        let _span = span!(Level::INFO, "reading packet", packet_type = ?packet_type).entered();
+        #[cfg(feature = "trace")]
-        event!(Level::INFO, "parsing packet");
+        {
+            let tick: u32 = stream.read()?;
+            stream.set_pos(stream.pos() - 32)?;
+            let _span =
+                span!(Level::INFO, "reading packet", packet_type = ?packet_type, tick = tick)
+                    .entered();
+            event!(Level::DEBUG, "parsing packet");
+        }
         Ok(match packet_type {
             PacketType::Signon => Packet::Signon(MessagePacket::parse(stream, state)?),
             PacketType::Message => Packet::Message(MessagePacket::parse(stream, state)?),
@@ -116,6 +124,8 @@ impl<'a> Parse<'a> for Packet<'a> {
 
 impl Encode for Packet<'_> {
     fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
+        #[cfg(feature = "trace")]
+        let _span = span!(Level::INFO, "encoding packet", packet_type = ?self.packet_type(), tick = self.tick()).entered();
         self.packet_type().write(stream)?;
         match self {
             Packet::Signon(inner) => inner.encode(stream, state),

src/demo/parser/state.rs

@@ -18,6 +18,7 @@ use crate::nullhasher::NullHasherBuilder;
 use crate::{Result, Stream};
 use serde::{Deserialize, Serialize};
 use std::cell::RefCell;
+#[cfg(feature = "trace")]
 use tracing::warn;
 
 #[derive(Default, Clone, Serialize, Deserialize)]
@@ -104,6 +105,7 @@ impl<'a> ParserState {
                     cached.entry(class_id).or_insert(props).clone()
                 }
                 None => {
+                    #[cfg(feature = "trace")]
                     warn!(
                         class_id = display(class_id),
                         "class without static baseline"
@@ -129,6 +131,7 @@ impl<'a> ParserState {
             _ => match self.static_baselines.get(&class_id) {
                 Some(_static_baseline) => self.get_static_baseline(class_id, send_table),
                 None => {
+                    #[cfg(feature = "trace")]
                     warn!(
                         class_id = display(class_id),
                         "class without static baseline"
@@ -169,6 +172,7 @@ impl<'a> ParserState {
                 if let Some(table) = send_tables.remove(&class.data_table) {
                     self.send_tables.push(table);
                 } else {
+                    #[cfg(feature = "trace")]
                     warn!(class = debug(class), "class without table");
                 }
             }