WIP pulse diff

streams/src/plaineventsjson.rs

@@ -44,7 +44,15 @@ pub async fn plain_events_json(
     //let inps = open_tcp_streams::<_, Box<dyn items_2::Events>>(&query, cluster).await?;
     // TODO propagate also the max-buf-len for the first stage event reader:
     let stream = items_2::merger::Merger::new(inps, 1024);
+    let stream = stream.map(|item| {
+        info!("item after merge: {item:?}");
+        item
+    });
     let stream = crate::rangefilter2::RangeFilter2::new(stream, query.range().clone(), evquery.one_before_range());
+    let stream = stream.map(|item| {
+        info!("item after rangefilter: {item:?}");
+        item
+    });
     let stream = stream::iter([empty]).chain(stream);
     let collected = crate::collect::collect(stream, deadline, events_max, Some(query.range().clone()), None).await?;
     let jsval = serde_json::to_value(&collected)?;

streams/src/rangefilter2.rs

@@ -176,6 +176,7 @@ where
                         Ok(StreamItem::DataItem(RangeCompletableItem::Data(item))) => match self.handle_item(item) {
                             Ok(item) => Ready(Some(Ok(StreamItem::DataItem(RangeCompletableItem::Data(item))))),
                             Err(e) => {
+                                error!("sees: {e}");
                                 self.data_done = true;
                                 Ready(Some(Err(e)))
                             }

streams/src/tcprawclient.rs

@@ -9,18 +9,24 @@ use crate::frames::eventsfromframes::EventsFromFrames;
 use crate::frames::inmem::InMemoryFrameAsyncReadStream;
 use err::Error;
 use futures_util::Stream;
+use futures_util::StreamExt;
 use items::eventfull::EventFull;
-use items::frame::{make_frame, make_term_frame};
+use items::frame::make_frame;
+use items::frame::make_term_frame;
 use items::sitem_data;
-use items::{EventQueryJsonStringFrame, RangeCompletableItem, Sitemty, StreamItem};
+use items::EventQueryJsonStringFrame;
+use items::RangeCompletableItem;
+use items::Sitemty;
+use items::StreamItem;
 use netpod::log::*;
 use netpod::query::PlainEventsQuery;
 use netpod::Cluster;
-use netpod::{Node, PerfOpts};
+use netpod::Node;
+use netpod::PerfOpts;
+use std::fmt;
 use std::pin::Pin;
 use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;
-use tracing::Instrument;
 
 pub async fn x_processed_event_blobs_stream_from_node(
     query: PlainEventsQuery,
@@ -55,7 +61,7 @@ pub async fn open_tcp_streams<Q, T>(query: Q, cluster: &Cluster) -> Result<Vec<B
 where
     Q: serde::Serialize,
     // Group bounds in new trait
-    T: items::FrameTypeInnerStatic + serde::de::DeserializeOwned + Send + Unpin + 'static,
+    T: items::FrameTypeInnerStatic + serde::de::DeserializeOwned + Send + Unpin + fmt::Debug + 'static,
 {
     // TODO when unit tests established, change to async connect:
     let mut streams = Vec::new();
@@ -73,11 +79,13 @@ where
         netout.flush().await?;
         netout.forget();
         // TODO for images, we need larger buffer capacity
-        let frames = InMemoryFrameAsyncReadStream::new(netin, 1024 * 1024 * 2)
-            //.instrument(netpod::log::span!(netpod::log::Level::TRACE, "InMemRd"))
-            ;
+        let frames = InMemoryFrameAsyncReadStream::new(netin, 1024 * 1024 * 2);
         let frames = Box::pin(frames) as _;
         let stream = EventsFromFrames::<T>::new(frames);
+        let stream = stream.map(|x| {
+            info!("tcp stream recv sees item {x:?}");
+            x
+        });
         streams.push(Box::pin(stream) as _);
     }
     Ok(streams)