Adapt to LogItem api

crates/httpret/src/api1.rs

@@ -732,19 +732,22 @@ impl DataApiPython3DataStream {
                     }
                 },
                 StreamItem::Log(k) => {
-                    let nodeix = k.node_ix;
-                    if k.level == Level::ERROR {
-                        tracing::event!(Level::ERROR, nodeix, message = k.msg);
-                    } else if k.level == Level::WARN {
-                        tracing::event!(Level::WARN, nodeix, message = k.msg);
-                    } else if k.level == Level::INFO {
-                        tracing::event!(Level::INFO, nodeix, message = k.msg);
-                    } else if k.level == Level::DEBUG {
-                        tracing::event!(Level::DEBUG, nodeix, message = k.msg);
-                    } else if k.level == Level::TRACE {
-                        tracing::event!(Level::TRACE, nodeix, message = k.msg);
-                    } else {
-                        tracing::event!(Level::TRACE, nodeix, message = k.msg);
+                    match k.level() {
+                        Level::ERROR => {
+                            error!("{}", k.display_log_file());
+                        }
+                        Level::WARN => {
+                            warn!("{}", k.display_log_file());
+                        }
+                        Level::INFO => {
+                            info!("{}", k.display_log_file());
+                        }
+                        Level::DEBUG => {
+                            debug!("{}", k.display_log_file());
+                        }
+                        Level::TRACE => {
+                            trace!("{}", k.display_log_file());
+                        }
                     }
                     Ok(BytesMut::new())
                 }

crates/httpret/src/api4/binned_v2.rs

@@ -280,10 +280,7 @@ async fn binned_json_framed(
         let stream = stream.map_err(Error::from);
         // let msg = format!("{}", res2.url.as_str());
         // let stream = futures_util::stream::iter([Ok(msg)]).chain(stream);
-        let stream = stream.map(|x| {
-            //
-            x
-        });
+        let stream = stream.map(|x| x);
 
         // use items_2::binning::timeweight::timeweight_bins::BinnedBinsTimeweight;
         use items_0::streamitem::StreamItem;
@@ -321,6 +318,7 @@ async fn binned_json_framed(
                 Err(e) => Err(e),
             }
         });
+        let stream = stream.map(|x| x);
         let stream = stream.map_err(|e| daqbuf_err::Error::from_string(e));
         let timeout_content_base = res2
             .query
@@ -328,11 +326,14 @@ async fn binned_json_framed(
             .unwrap_or(Duration::from_millis(2000))
             .min(Duration::from_millis(8000))
             .max(Duration::from_millis(334));
+        let stream = stream.map(|x| x);
+        let stream = streams::logqueue::LogItemMux::new(stream, ctx.reqid().into());
         let timeout_content_2 = timeout_content_base * 2 / 3;
         let stream = stream.map(|x| Some(x)).chain(futures_util::stream::iter([None]));
         let stream = TimeoutableStream::new(timeout_content_base, res2.timeout_provider, stream);
+        let stream = stream.map(|x| x);
         let stream = Box::pin(stream);
-        let stream = timeoutable_collectable_stream_to_json_bytes(stream, timeout_content_2);
+        let stream = timeoutable_collectable_stream_to_json_bytes(stream, timeout_content_2, true);
         // let stream = stream.map(|x| Ok(format!("dummy82749827348932")));
         // Box::pin(stream) as Pin<Box<dyn Stream<Item = _> + Send>>
         stream

crates/httpret/src/httpret.rs

@@ -228,6 +228,19 @@ async fn the_service_fn(
     shared_res: Arc<ServiceSharedResources>,
 ) -> Result<StreamResponse, Error> {
     let ctx = ReqCtx::new_with_node(&req, &node_config);
+    let reqid = ctx.reqid().into();
+    let fut = the_service_fn_log_enabled(ctx, req, addr, node_config, service_version, shared_res);
+    streams::logqueue::LogQueueFutureWrap::new(reqid, fut).await
+}
+
+async fn the_service_fn_log_enabled(
+    ctx: ReqCtx,
+    req: Requ,
+    addr: SocketAddr,
+    node_config: NodeConfigCached,
+    service_version: ServiceVersion,
+    shared_res: Arc<ServiceSharedResources>,
+) -> Result<StreamResponse, Error> {
     let reqid_span = span!(Level::INFO, "req", reqid = ctx.reqid());
     let f = http_service(req, addr, ctx, node_config, service_version, shared_res);
     let f = Cont { f: Box::pin(f) };