Not bad, I get Streamlog LogItem in the test

disk/src/agg/binnedt.rs

@@ -1,4 +1,5 @@
 use crate::agg::AggregatableXdim1Bin;
+use crate::streamlog::LogItem;
 use err::Error;
 use futures_core::Stream;
 use futures_util::StreamExt;
@@ -24,6 +25,9 @@ pub trait AggregatableTdim: Sized {
     fn aggregator_new_static(ts1: u64, ts2: u64) -> Self::Aggregator;
     fn is_range_complete(&self) -> bool;
     fn make_range_complete_item() -> Option<Self>;
+    fn is_log_item(&self) -> bool;
+    fn log_item(self) -> Option<LogItem>;
+    fn make_log_item(item: LogItem) -> Option<Self>;
 }
 
 pub trait IntoBinnedT {
@@ -140,6 +144,19 @@ where
                     if k.is_range_complete() {
                         self.range_complete = true;
                         continue 'outer;
+                    } else if k.is_log_item() {
+                        if let Some(item) = k.log_item() {
+                            if let Some(item) =
+                                <I::Aggregator as AggregatorTdim>::OutputValue::make_log_item(item.clone())
+                            {
+                                Ready(Some(Ok(item)))
+                            } else {
+                                warn!("IntoBinnedTDefaultStream  can not create log item");
+                                continue 'outer;
+                            }
+                        } else {
+                            panic!()
+                        }
                     } else {
                         let ag = self.aggtor.as_mut().unwrap();
                         if ag.ends_before(&k) {

disk/src/agg/eventbatch.rs

@@ -1,6 +1,7 @@
 use crate::agg::binnedt::{AggregatableTdim, AggregatorTdim};
 use crate::agg::scalarbinbatch::{MinMaxAvgScalarBinBatch, MinMaxAvgScalarBinBatchStreamItem};
 use crate::agg::AggregatableXdim1Bin;
+use crate::streamlog::LogItem;
 use bytes::{BufMut, Bytes, BytesMut};
 use netpod::log::*;
 use netpod::timeunits::SEC;
@@ -120,6 +121,18 @@ impl AggregatableTdim for MinMaxAvgScalarEventBatch {
     fn make_range_complete_item() -> Option<Self> {
         None
     }
+
+    fn is_log_item(&self) -> bool {
+        false
+    }
+
+    fn log_item(self) -> Option<LogItem> {
+        None
+    }
+
+    fn make_log_item(_item: LogItem) -> Option<Self> {
+        None
+    }
 }
 
 impl MinMaxAvgScalarEventBatch {
@@ -266,6 +279,7 @@ pub enum MinMaxAvgScalarEventBatchStreamItem {
     Values(MinMaxAvgScalarEventBatch),
     RangeComplete,
     EventDataReadStats(EventDataReadStats),
+    Log(LogItem),
 }
 
 impl AggregatableXdim1Bin for MinMaxAvgScalarEventBatchStreamItem {
@@ -296,6 +310,26 @@ impl AggregatableTdim for MinMaxAvgScalarEventBatchStreamItem {
     fn make_range_complete_item() -> Option<Self> {
         Some(MinMaxAvgScalarEventBatchStreamItem::RangeComplete)
     }
+
+    fn is_log_item(&self) -> bool {
+        if let MinMaxAvgScalarEventBatchStreamItem::Log(_) = self {
+            true
+        } else {
+            false
+        }
+    }
+
+    fn log_item(self) -> Option<LogItem> {
+        if let MinMaxAvgScalarEventBatchStreamItem::Log(item) = self {
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    fn make_log_item(item: LogItem) -> Option<Self> {
+        Some(MinMaxAvgScalarEventBatchStreamItem::Log(item))
+    }
 }
 
 pub struct MinMaxAvgScalarEventBatchStreamItemAggregator {
@@ -343,6 +377,7 @@ impl AggregatorTdim for MinMaxAvgScalarEventBatchStreamItemAggregator {
             MinMaxAvgScalarEventBatchStreamItem::Values(vals) => self.agg.ingest(vals),
             MinMaxAvgScalarEventBatchStreamItem::EventDataReadStats(stats) => self.event_data_read_stats.trans(stats),
             MinMaxAvgScalarEventBatchStreamItem::RangeComplete => (),
+            MinMaxAvgScalarEventBatchStreamItem::Log(_) => (),
         }
     }
 

disk/src/agg/scalarbinbatch.rs

@@ -1,5 +1,6 @@
 use crate::agg::binnedt::{AggregatableTdim, AggregatorTdim};
 use crate::agg::{AggregatableXdim1Bin, Fits, FitsInside};
+use crate::streamlog::LogItem;
 use bytes::{BufMut, Bytes, BytesMut};
 use netpod::log::*;
 use netpod::timeunits::SEC;
@@ -201,6 +202,18 @@ impl AggregatableTdim for MinMaxAvgScalarBinBatch {
     fn make_range_complete_item() -> Option<Self> {
         None
     }
+
+    fn is_log_item(&self) -> bool {
+        false
+    }
+
+    fn log_item(self) -> Option<LogItem> {
+        None
+    }
+
+    fn make_log_item(_item: LogItem) -> Option<Self> {
+        None
+    }
 }
 
 pub struct MinMaxAvgScalarBinBatchAggregator {
@@ -295,6 +308,7 @@ pub enum MinMaxAvgScalarBinBatchStreamItem {
     Values(MinMaxAvgScalarBinBatch),
     RangeComplete,
     EventDataReadStats(EventDataReadStats),
+    Log(LogItem),
 }
 
 impl AggregatableTdim for MinMaxAvgScalarBinBatchStreamItem {
@@ -316,6 +330,26 @@ impl AggregatableTdim for MinMaxAvgScalarBinBatchStreamItem {
     fn make_range_complete_item() -> Option<Self> {
         Some(MinMaxAvgScalarBinBatchStreamItem::RangeComplete)
     }
+
+    fn is_log_item(&self) -> bool {
+        if let MinMaxAvgScalarBinBatchStreamItem::Log(_) = self {
+            true
+        } else {
+            false
+        }
+    }
+
+    fn log_item(self) -> Option<LogItem> {
+        if let MinMaxAvgScalarBinBatchStreamItem::Log(item) = self {
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    fn make_log_item(item: LogItem) -> Option<Self> {
+        Some(MinMaxAvgScalarBinBatchStreamItem::Log(item))
+    }
 }
 
 impl AggregatableXdim1Bin for MinMaxAvgScalarBinBatchStreamItem {
@@ -371,6 +405,7 @@ impl AggregatorTdim for MinMaxAvgScalarBinBatchStreamItemAggregator {
             MinMaxAvgScalarBinBatchStreamItem::Values(vals) => self.agg.ingest(vals),
             MinMaxAvgScalarBinBatchStreamItem::EventDataReadStats(stats) => self.event_data_read_stats.trans(stats),
             MinMaxAvgScalarBinBatchStreamItem::RangeComplete => (),
+            MinMaxAvgScalarBinBatchStreamItem::Log(_) => (),
         }
     }