bd-proto-util: Use Default for missing map entry fields per protobuf spec

Per protobuf specification, when a map entry is missing its key or value field,
the type's default value should be used instead of returning an error.

Changes:
- Add Default bounds to deserialize_map_entry generic parameters
- Use unwrap_or_default() instead of returning errors for missing fields
- Add Default bounds to HashMap/AHashMap ProtoFieldDeserialize impls
- Update documentation to reflect protobuf-compatible behavior

This allows map types to support any value type that implements Default.
For types without Default (like OffsetDateTime), users should wrap them
in Option<T> so that None is the default, avoiding epoch timestamps.

Author: snowp

Cargo.lock

@@ -24,6 +24,7 @@ members = [
   "bd-logger",
   "bd-log-filter",
   "bd-log-matcher",
+  "bd-macros",
   "bd-internal-logging",
   "bd-network-quality",
   "bd-noop-network",

Cargo.toml

@@ -12,6 +12,7 @@ doctest = false
 ahash.workspace             = true
 anyhow.workspace            = true
 bd-proto                    = { path = "../bd-proto" }
+bd-proto-util               = { path = "../bd-proto-util" }
 bd-workspace-hack.workspace = true
 flate2                      = { workspace = true, default-features = false, features = ["zlib"] }
 ordered-float.workspace     = true

bd-log-primitives/Cargo.toml

@@ -28,6 +28,7 @@ use crate::zlib::DEFAULT_MOBILE_ZLIB_COMPRESSION_LEVEL;
 use ahash::AHashMap;
 use bd_proto::protos::logging::payload::data::Data_type;
 use bd_proto::protos::logging::payload::{BinaryData, Data, LogType};
+use bd_proto_util::serialization::{ProtoFieldSerialize, TimestampMicros};
 use flate2::Compression;
 use flate2::write::ZlibEncoder;
 use ordered_float::NotNan;
@@ -143,6 +144,7 @@ impl StringOrBytes<String, Vec<u8>> {
 
 impl<T: AsRef<str>, B: AsRef<[u8]>> StringOrBytes<T, B> {
   /// Extracts the underlying str if the enum represents a String, None otherwise.
+  #[must_use]
   pub fn as_str(&self) -> Option<&str> {
     match self {
       Self::String(s) => Some(s.as_ref()),
@@ -153,6 +155,7 @@ impl<T: AsRef<str>, B: AsRef<[u8]>> StringOrBytes<T, B> {
   }
 
   /// Extracts the underlying bytes if the enum represents a Bytes, None otherwise.
+  #[must_use]
   pub fn as_bytes(&self) -> Option<&[u8]> {
     match self {
       Self::String(_)
@@ -572,8 +575,10 @@ impl LogEncodingHelper {
 
         // uint64 timestamp_unix_micro = 1;
         // No zero check is this should always be set.
-        my_size +=
-          ::protobuf::rt::uint64_size(1, occurred_at.unix_timestamp_nanos().to_u64_lossy() / 1000);
+        // We manually serialize this as a uint64 (microsecond timestamp) to match the proto
+        // definition.
+        let micros = TimestampMicros::new(occurred_at).as_micros();
+        my_size += protobuf::rt::uint64_size(1, micros);
 
         // uint32 log_level = 2;
         if log_level != 0 {
@@ -585,9 +590,7 @@ impl LogEncodingHelper {
         my_size += ::protobuf::rt::string_size(5, session_id);
 
         // LogType log_type = 7;
-        if log_type != LogType::NORMAL {
-          my_size += ::protobuf::rt::int32_size(7, log_type as i32);
-        }
+        my_size += <LogType as ProtoFieldSerialize>::compute_size(&log_type, 7);
 
         *cached_encoding_data = Some(CachedEncodingData {
           core_size: my_size,
@@ -646,7 +649,10 @@ impl LogEncodingHelper {
     cached_encoding_data: Option<&CachedEncodingData>,
   ) -> anyhow::Result<()> {
     // uint64 timestamp_unix_micro = 1;
-    os.write_uint64(1, occurred_at.unix_timestamp_nanos().to_u64_lossy() / 1000)?;
+    // We manually serialize this as a uint64 (microsecond timestamp) to match the proto definition.
+    let micros = TimestampMicros::new(occurred_at).as_micros();
+    os.write_tag(1, protobuf::rt::WireType::Varint)?;
+    os.write_uint64_no_tag(micros)?;
 
     // uint32 log_level = 2;
     if log_level != 0 {
@@ -674,9 +680,7 @@ impl LogEncodingHelper {
     }
 
     // LogType log_type = 7;
-    if log_type != LogType::NORMAL {
-      os.write_enum(7, log_type as i32)?;
-    }
+    <LogType as ProtoFieldSerialize>::serialize(&log_type, 7, os)?;
 
     // repeated string stream_ids = 8;
     for v in stream_ids {
@@ -734,7 +738,9 @@ impl LogEncodingHelper {
     if raw_tag == 8 // field number 1, wire type 0
       && let Some(ts_micros) = cis.read_uint64().ok()
     {
-      return OffsetDateTime::from_unix_timestamp_nanos((ts_micros * 1000).into()).ok();
+      return TimestampMicros::from_micros(ts_micros)
+        .ok()
+        .map(TimestampMicros::into_inner);
     }
 
     None

bd-log-primitives/src/lib.rs

@@ -99,6 +99,20 @@ impl<T: PartialEq> FromIterator<T> for TinySet<T> {
   }
 }
 
+impl<T: PartialEq> Extend<T> for TinySet<T> {
+  fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+    self.inner.extend(iter.into_iter().map(|item| (item, ())));
+  }
+}
+
+impl<T: PartialEq> Extend<Self> for TinySet<T> {
+  fn extend<I: IntoIterator<Item = Self>>(&mut self, iter: I) {
+    for set in iter {
+      self.inner.extend(set.inner);
+    }
+  }
+}
+
 impl<T: PartialEq, const N: usize> From<[T; N]> for TinySet<T> {
   fn from(arr: [T; N]) -> Self {
     Self {
@@ -119,6 +133,18 @@ impl<T> IntoIterator for TinySet<T> {
   }
 }
 
+impl<'a, T> IntoIterator for &'a TinySet<T> {
+  type Item = &'a T;
+  type IntoIter = std::iter::Map<std::slice::Iter<'a, (T, ())>, fn(&'a (T, ())) -> &'a T>;
+
+  fn into_iter(self) -> Self::IntoIter {
+    fn map_ref<T>((k, ()): &(T, ())) -> &T {
+      k
+    }
+    self.inner.items.iter().map(map_ref)
+  }
+}
+
 //
 // TinyMap
 //
@@ -129,6 +155,10 @@ pub struct TinyMap<K, V> {
 }
 
 impl<K: PartialEq, V> TinyMap<K, V> {
+  pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
+    self.items.iter().map(|(k, v)| (k, v))
+  }
+
   pub fn get<Q>(&self, key: &Q) -> Option<&V>
   where
     K: Borrow<Q>,
@@ -209,6 +239,18 @@ impl<K, V> IntoIterator for TinyMap<K, V> {
   }
 }
 
+impl<'a, K, V> IntoIterator for &'a TinyMap<K, V> {
+  type Item = (&'a K, &'a V);
+  type IntoIter = std::iter::Map<std::slice::Iter<'a, (K, V)>, fn(&'a (K, V)) -> (&'a K, &'a V)>;
+
+  fn into_iter(self) -> Self::IntoIter {
+    fn map_ref<K, V>((k, v): &(K, V)) -> (&K, &V) {
+      (k, v)
+    }
+    self.items.iter().map(map_ref)
+  }
+}
+
 impl<K: PartialEq, V> FromIterator<(K, V)> for TinyMap<K, V> {
   fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
     let mut new = Self::default();
@@ -225,8 +267,69 @@ impl<K: PartialEq, V, const N: usize> From<[(K, V); N]> for TinyMap<K, V> {
   }
 }
 
+impl<K: PartialEq, V> Extend<(K, V)> for TinyMap<K, V> {
+  fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I) {
+    for (k, v) in iter {
+      self.insert(k, v);
+    }
+  }
+}
+
+impl<K: PartialEq, V> Extend<Self> for TinyMap<K, V> {
+  fn extend<I: IntoIterator<Item = Self>>(&mut self, iter: I) {
+    for map in iter {
+      for (k, v) in map {
+        self.insert(k, v);
+      }
+    }
+  }
+}
+
 impl<K, V> Default for TinyMap<K, V> {
   fn default() -> Self {
     Self { items: Vec::new() }
   }
 }
+
+// ProtoFieldSerialize/ProtoFieldDeserialize implementations for TinySet<T>
+// TinySet is serialized as a repeated field in protobuf.
+bd_proto_util::impl_proto_repeated!(TinySet<T>, T, PartialEq);
+
+// ProtoFieldSerialize/ProtoFieldDeserialize implementations for TinyMap
+// TinyMap is serialized as a map field (repeated key-value pairs) in protobuf.
+impl<K, V> bd_proto_util::serialization::ProtoType for TinyMap<K, V> {
+  fn wire_type() -> protobuf::rt::WireType {
+    protobuf::rt::WireType::LengthDelimited
+  }
+}
+
+impl<K, V> bd_proto_util::serialization::ProtoFieldSerialize for TinyMap<K, V>
+where
+  K: bd_proto_util::serialization::ProtoFieldSerialize + PartialEq,
+  V: bd_proto_util::serialization::ProtoFieldSerialize,
+{
+  fn compute_size(&self, field_number: u32) -> u64 {
+    bd_proto_util::serialization::compute_map_size(self, field_number)
+  }
+
+  fn serialize(
+    &self,
+    field_number: u32,
+    os: &mut protobuf::CodedOutputStream<'_>,
+  ) -> anyhow::Result<()> {
+    bd_proto_util::serialization::serialize_map(self, field_number, os)
+  }
+}
+
+impl<K, V> bd_proto_util::serialization::ProtoFieldDeserialize for TinyMap<K, V>
+where
+  K: bd_proto_util::serialization::ProtoFieldDeserialize + PartialEq + Default,
+  V: bd_proto_util::serialization::ProtoFieldDeserialize + Default,
+{
+  fn deserialize(is: &mut protobuf::CodedInputStream<'_>) -> anyhow::Result<Self> {
+    let (key, value) = bd_proto_util::serialization::deserialize_map_entry(is)?;
+    let mut map = Self::default();
+    map.extend(std::iter::once((key, value)));
+    Ok(map)
+  }
+}

bd-log-primitives/src/tiny_set.rs

@@ -0,0 +1,16 @@
+[package]
+edition      = "2024"
+license-file = "../LICENSE"
+name         = "bd-macros"
+publish      = false
+version      = "1.0.0"
+
+[lib]
+doctest    = false
+proc-macro = true
+
+[dependencies]
+bd-workspace-hack.workspace = true
+proc-macro2                 = "1.0"
+quote                       = "1.0"
+syn                         = { version = "2.0", features = ["full"] }