refactor: move varint into its own file

Author: morrisonlevi

datadog-profiling-protobuf/src/function.rs

@@ -19,18 +19,18 @@ impl Value for Function {
 
     fn proto_len(&self) -> u64 {
         Varint(self.id).field(1).proto_len()
-            + Varint(self.name.to_u64()).field(2).proto_len_small()
-            + Varint(self.system_name.to_u64()).field(3).proto_len_small()
-            + Varint(self.filename.to_u64()).field(4).proto_len_small()
+            + Varint::from(self.name).field(2).proto_len_small()
+            + Varint::from(self.system_name).field(3).proto_len_small()
+            + Varint::from(self.filename).field(4).proto_len_small()
     }
 
     fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         Varint(self.id).field(1).encode(writer)?;
-        Varint(self.name.into()).field(2).encode_small(writer)?;
-        Varint(self.system_name.into())
+        Varint::from(self.name).field(2).encode_small(writer)?;
+        Varint::from(self.system_name)
             .field(3)
             .encode_small(writer)?;
-        Varint(self.filename.into()).field(4).encode_small(writer)
+        Varint::from(self.filename).field(4).encode_small(writer)
     }
 }
 

datadog-profiling-protobuf/src/label.rs

@@ -20,17 +20,17 @@ impl Value for Label {
     const WIRE_TYPE: WireType = WireType::LengthDelimited;
 
     fn proto_len(&self) -> u64 {
-        Varint::from(self.key.to_u64()).field(1).proto_len()
-            + Varint(self.str.to_u64()).field(2).proto_len_small()
-            + Varint(self.num as u64).field(3).proto_len_small()
-            + Varint(self.num_unit.to_u64()).field(4).proto_len_small()
+        Varint::from(self.key).field(1).proto_len()
+            + Varint::from(self.str).field(2).proto_len_small()
+            + Varint::from(self.num).field(3).proto_len_small()
+            + Varint::from(self.num_unit).field(4).proto_len_small()
     }
 
     fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
-        Varint::from(self.key.to_u64()).field(1).encode(writer)?;
-        Varint(self.str.into()).field(2).encode_small(writer)?;
-        Varint(self.num as u64).field(3).encode_small(writer)?;
-        Varint(self.num_unit.into()).field(4).encode_small(writer)
+        Varint::from(self.key).field(1).encode(writer)?;
+        Varint::from(self.str).field(2).encode_small(writer)?;
+        Varint::from(self.num).field(3).encode_small(writer)?;
+        Varint::from(self.num_unit).field(4).encode_small(writer)
     }
 }
 

datadog-profiling-protobuf/src/lib.rs

@@ -13,6 +13,7 @@ mod mapping;
 mod sample;
 mod string;
 mod value_type;
+mod varint;
 
 #[cfg(feature = "prost_impls")]
 pub mod prost_impls;
@@ -24,6 +25,7 @@ pub use mapping::*;
 pub use sample::*;
 pub use string::*;
 pub use value_type::*;
+pub use varint::*;
 
 use std::io::{self, Write};
 
@@ -52,12 +54,6 @@ pub trait Value {
     }
 }
 
-/// You can use varint to store any of the listed data types:
-/// int32 | int64 | uint32 | uint64 | bool | enum | sint32 | sint64
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct Varint(pub u64);
-
 /// A tag and value pair.
 ///
 /// The wire type isn't stored; it's provided by the Value implementation,
@@ -122,9 +118,6 @@ const MIN_FIELD: u32 = 1;
 /// The largest possible protobuf field number.
 const MAX_FIELD: u32 = (1 << 29) - 1;
 
-/// An encoded 64-bit unsigned number takes between 1 and 10 bytes, inclusive.
-pub const MAX_VARINT_LEN: u64 = 10;
-
 /// Represents the wire type for in-wire protobuf. There are more types than
 /// are represented here; these are just the supported ones.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -133,72 +126,6 @@ pub enum WireType {
     Varint = 0,
     LengthDelimited = 2,
 }
-impl Varint {
-    /// Returns the number of bytes it takes to encode a varint. This is
-    /// between 1 and 10 bytes, inclusive.
-    pub const fn proto_len(&self) -> u64 {
-        // https://github.com/google/protobuf/blob/3.3.x/src/google/protobuf/io/coded_stream.h#L1301-L1309
-        ((((self.0 | 1).leading_zeros() ^ 63) * 9 + 73) / 64) as u64
-    }
-}
-
-impl Value for Varint {
-    const WIRE_TYPE: WireType = WireType::Varint;
-
-    fn proto_len(&self) -> u64 {
-        self.proto_len()
-    }
-
-    /// Encodes a varint according to protobuf semantics.
-    ///
-    /// Note that it will write between 1 and 10 bytes, inclusive. You should
-    /// probably write to a buffered Write object--if you write directly to
-    /// something like a TCP stream, it's going to send one byte at a time,
-    /// which is excessively inefficient. In libdatadog, we typically write to
-    /// some sort of compressor which has its own input buffer.
-    ///
-    /// See https://protobuf.dev/programming-guides/encoding/#varints
-    #[inline]
-    fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
-        let mut value = self.0;
-        loop {
-            let byte = if value < 0x80 {
-                value as u8
-            } else {
-                ((value & 0x7F) | 0x80) as u8
-            };
-            writer.write_all(&[byte])?;
-            if value < 0x80 {
-                return Ok(());
-            }
-            value >>= 7;
-        }
-    }
-}
-
-impl From<u64> for Varint {
-    fn from(value: u64) -> Self {
-        Varint(value)
-    }
-}
-
-impl From<&u64> for Varint {
-    fn from(value: &u64) -> Self {
-        Varint(*value)
-    }
-}
-
-impl From<i64> for Varint {
-    fn from(value: i64) -> Self {
-        Varint(value as u64)
-    }
-}
-
-impl From<&i64> for Varint {
-    fn from(value: &i64) -> Self {
-        Varint(*value as u64)
-    }
-}
 
 impl Tag {
     #[cfg_attr(debug_assertions, track_caller)]
@@ -209,7 +136,7 @@ impl Tag {
     }
 
     #[inline]
-    pub const fn proto_len(self) -> u64 {
+    pub fn proto_len(self) -> u64 {
         self.into_varint().proto_len()
     }
 
@@ -257,14 +184,3 @@ where
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn max_varint_len() {
-        assert_eq!(MAX_VARINT_LEN, 10);
-        assert_eq!(MAX_VARINT_LEN, Varint(u64::MAX).proto_len());
-    }
-}

datadog-profiling-protobuf/src/location.rs

@@ -1,7 +1,8 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{Tag, Value, Varint, WireType};
+use crate::varint::Varint;
+use crate::{Tag, Value, WireType};
 use std::io::{self, Write};
 
 #[repr(C)]
@@ -27,12 +28,12 @@ impl Value for Line {
 
     fn proto_len(&self) -> u64 {
         Varint(self.function_id).field(1).proto_len_small()
-            + Varint(self.lineno as u64).field(2).proto_len_small()
+            + Varint::from(self.lineno).field(2).proto_len_small()
     }
 
     fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         Varint(self.function_id).field(1).encode_small(writer)?;
-        Varint(self.lineno as u64).field(2).encode_small(writer)
+        Varint::from(self.lineno).field(2).encode_small(writer)
     }
 }
 

datadog-profiling-protobuf/src/mapping.rs

@@ -26,17 +26,17 @@ impl Value for Mapping {
             + Varint(self.memory_start).field(2).proto_len_small()
             + Varint(self.memory_limit).field(3).proto_len_small()
             + Varint(self.file_offset).field(4).proto_len_small()
-            + Varint(self.filename.to_u64()).field(5).proto_len_small()
-            + Varint(self.build_id.to_u64()).field(6).proto_len_small()
+            + Varint::from(self.filename).field(5).proto_len_small()
+            + Varint::from(self.build_id).field(6).proto_len_small()
     }
 
     fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         Varint(self.id).field(1).encode(writer)?;
         Varint(self.memory_start).field(2).encode_small(writer)?;
         Varint(self.memory_limit).field(3).encode_small(writer)?;
         Varint(self.file_offset).field(4).encode_small(writer)?;
-        Varint(self.filename.into()).field(5).encode_small(writer)?;
-        Varint(self.build_id.into()).field(6).encode_small(writer)
+        Varint::from(self.filename).field(5).encode_small(writer)?;
+        Varint::from(self.build_id).field(6).encode_small(writer)
     }
 }
 

datadog-profiling-protobuf/src/string.rs

@@ -21,6 +21,8 @@ impl Value for &str {
 /// equal to 2 GiB. By the time you encode the tag and length prefix for each
 /// string, there's no way to get this many unique-ish strings without first
 /// exceeding the protobuf 2 GiB limit.
+///
+/// A value of 0 means "no string" or "empty string" (they are synonymous).
 #[repr(C)]
 #[derive(Copy, Clone, Default, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 #[cfg_attr(test, derive(bolero::generator::TypeGenerator))]
@@ -158,9 +160,4 @@ impl StringOffset {
     pub const fn is_zero(&self) -> bool {
         self.0 == 0
     }
-
-    #[inline]
-    pub const fn to_u64(&self) -> u64 {
-        self.0 as u64
-    }
 }

datadog-profiling-protobuf/src/value_type.rs

@@ -16,13 +16,13 @@ impl Value for ValueType {
     const WIRE_TYPE: WireType = WireType::LengthDelimited;
 
     fn proto_len(&self) -> u64 {
-        Varint(self.r#type.to_u64()).field(1).proto_len_small()
-            + Varint(self.unit.to_u64()).field(2).proto_len_small()
+        Varint::from(self.r#type).field(1).proto_len_small()
+            + Varint::from(self.unit).field(2).proto_len_small()
     }
 
     fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
-        Varint(self.r#type.into()).field(1).encode_small(writer)?;
-        Varint(self.unit.into()).field(2).encode_small(writer)
+        Varint::from(self.r#type).field(1).encode_small(writer)?;
+        Varint::from(self.unit).field(2).encode_small(writer)
     }
 }
 

datadog-profiling-protobuf/src/varint.rs

@@ -0,0 +1,95 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{StringOffset, Value, WireType};
+use std::io::{self, Write};
+
+/// You can use varint to store any of the listed data types:
+/// int32 | int64 | uint32 | uint64 | bool | enum | sint32 | sint64
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct Varint(pub u64);
+
+impl Value for Varint {
+    const WIRE_TYPE: WireType = WireType::Varint;
+
+    /// Returns the number of bytes it takes to encode a varint. This is
+    /// between 1 and 10 bytes, inclusive.
+    fn proto_len(&self) -> u64 {
+        // https://github.com/google/protobuf/blob/3.3.x/src/google/protobuf/io/coded_stream.h#L1301-L1309
+        ((((self.0 | 1).leading_zeros() ^ 63) * 9 + 73) / 64) as u64
+    }
+
+    /// Encodes a varint according to protobuf semantics.
+    ///
+    /// Note that it will write between 1 and 10 bytes, inclusive. You should
+    /// probably write to a buffered Write object--if you write directly to
+    /// something like a TCP stream, it's going to send one byte at a time,
+    /// which is excessively inefficient. In libdatadog, we typically write to
+    /// some sort of compressor which has its own input buffer.
+    ///
+    /// See https://protobuf.dev/programming-guides/encoding/#varints
+    #[inline]
+    fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
+        let mut value = self.0;
+        loop {
+            let byte = if value < 0x80 {
+                value as u8
+            } else {
+                ((value & 0x7F) | 0x80) as u8
+            };
+            writer.write_all(&[byte])?;
+            if value < 0x80 {
+                return Ok(());
+            }
+            value >>= 7;
+        }
+    }
+}
+
+impl From<u64> for Varint {
+    fn from(value: u64) -> Self {
+        Varint(value)
+    }
+}
+
+impl From<&u64> for Varint {
+    fn from(value: &u64) -> Self {
+        Varint(*value)
+    }
+}
+
+impl From<i64> for Varint {
+    fn from(value: i64) -> Self {
+        Varint(value as u64)
+    }
+}
+
+impl From<&i64> for Varint {
+    fn from(value: &i64) -> Self {
+        Varint(*value as u64)
+    }
+}
+
+impl From<StringOffset> for Varint {
+    fn from(string_offset: StringOffset) -> Self {
+        Self(u64::from(string_offset))
+    }
+}
+
+impl From<&StringOffset> for Varint {
+    fn from(string_offset: &StringOffset) -> Self {
+        Self(u64::from(string_offset))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn max_varint_len() {
+        assert_eq!(Varint(0).proto_len(), 1);
+        assert_eq!(Varint(u64::MAX).proto_len(), 10);
+    }
+}