improve tracing

amqp_messaging/src/lib.rs

@@ -1,8 +1,9 @@
 #![warn(rust_2018_idioms)]
+#![deny(clippy::future_not_send)]
 
 use amqp_core::error::ProtocolError;
 
 pub mod methods;
-mod queue;
+mod queue_worker;
 
 type Result<T> = std::result::Result<T, ProtocolError>;

amqp_messaging/src/methods/mod.rs

@@ -6,8 +6,8 @@ use crate::Result;
 use amqp_core::{amqp_todo, connection::Channel, message::Message, methods::Method};
 use tracing::{error, info};
 
-pub async fn handle_basic_publish(channel_handle: Channel, message: Message) {
-    match publish::publish(channel_handle, message).await {
+pub fn handle_basic_publish(channel_handle: Channel, message: Message) {
+    match publish::publish(channel_handle, message) {
         Ok(()) => {}
         Err(err) => error!(%err, "publish error occurred"),
     }

amqp_messaging/src/methods/publish.rs

@@ -1,14 +1,14 @@
 use crate::Result;
 use amqp_core::{
     amqp_todo,
-    connection::{Channel, ConnectionEvent},
+    connection::Channel,
     error::{ChannelException, ConException},
     message::Message,
-    methods::{BasicDeliver, Method},
+    queue::QueueEvent,
 };
-use tracing::debug;
+use tracing::{debug, error};
 
-pub async fn publish(channel_handle: Channel, message: Message) -> Result<()> {
+pub fn publish(channel_handle: Channel, message: Message) -> Result<()> {
     debug!(?message, "Publishing message");
 
     let global_data = channel_handle.global_data.clone();
@@ -19,38 +19,20 @@ pub async fn publish(channel_handle: Channel, message: Message) -> Result<()> {
         amqp_todo!();
     }
 
-    let mut global_data = global_data.lock();
+    let global_data = global_data.lock();
 
     let queue = global_data
         .queues
-        .get_mut(routing.routing_key.as_str())
+        .get(routing.routing_key.as_str())
         .ok_or(ChannelException::NotFound)?;
 
-    {
-        // todo: we just send it to the consumer directly and ignore it if the consumer doesn't exist
-        // consuming is hard, but this should work *for now*
-        let consumers = queue.consumers.lock();
-        if let Some(consumer) = consumers.values().next() {
-            let method = Box::new(Method::BasicDeliver(BasicDeliver {
-                consumer_tag: consumer.tag.clone(),
-                delivery_tag: 0,
-                redelivered: false,
-                exchange: routing.exchange.clone(),
-                routing_key: routing.routing_key.clone(),
-            }));
-
-            consumer
-                .channel
-                .event_sender
-                .try_send(ConnectionEvent::MethodContent(
-                    consumer.channel.num,
-                    method,
-                    message.header.clone(),
-                    message.content.clone(),
-                ))
-                .map_err(|_| ConException::InternalError)?;
-        }
-    }
+    queue
+        .event_send
+        .try_send(QueueEvent::PublishMessage(message))
+        .map_err(|err| {
+            error!(?err, "Failed to send message to queue event queue");
+            ConException::InternalError
+        })?;
 
     Ok(())
 }

amqp_messaging/src/methods/queue.rs

@@ -1,4 +1,4 @@
-use crate::{queue::QueueTask, Result};
+use crate::{queue_worker::QueueTask, Result};
 use amqp_core::{
     amqp_todo,
     connection::Channel,
@@ -9,7 +9,6 @@ use amqp_core::{
 use parking_lot::Mutex;
 use std::sync::{atomic::AtomicUsize, Arc};
 use tokio::sync::mpsc;
-use tracing::{info_span, Instrument};
 
 pub fn declare(channel: Channel, queue_declare: QueueDeclare) -> Result<Method> {
     let QueueDeclare {
@@ -68,8 +67,7 @@ pub fn declare(channel: Channel, queue_declare: QueueDeclare) -> Result<Method>
 
     let queue_task = QueueTask::new(global_data, event_recv, queue);
 
-    let queue_worker_span = info_span!(parent: None, "queue-worker", %queue_name);
-    tokio::spawn(queue_task.start().instrument(queue_worker_span));
+    tokio::spawn(async move { queue_task.start().await });
 
     Ok(Method::QueueDeclareOk(QueueDeclareOk {
         queue: queue_name.to_string(),

amqp_messaging/src/queue.rs

@@ -1,43 +0,0 @@
-use amqp_core::{
-    queue::{Queue, QueueEventReceiver},
-    GlobalData,
-};
-use tracing::{debug, info};
-
-#[derive(Debug)]
-#[allow(dead_code)]
-pub struct QueueTask {
-    global_data: GlobalData,
-    event_recv: QueueEventReceiver,
-    queue: Queue,
-}
-
-impl QueueTask {
-    pub fn new(global_data: GlobalData, event_recv: QueueEventReceiver, queue: Queue) -> Self {
-        Self {
-            global_data,
-            event_recv,
-            queue,
-        }
-    }
-
-    pub async fn start(mut self) {
-        info!("Started queue worker task");
-
-        loop {
-            let next_event = self.event_recv.recv().await;
-
-            match next_event {
-                Some(event) => debug!(?event, "Received event"),
-                None => {
-                    self.cleanup().await;
-                    return;
-                }
-            }
-        }
-    }
-
-    async fn cleanup(&mut self) {
-        // do stuff or something like that id whatever
-    }
-}

amqp_messaging/src/queue_worker.rs

@@ -0,0 +1,102 @@
+use amqp_core::{
+    connection::ConnectionEvent,
+    consumer::Consumer,
+    message::Message,
+    methods::{BasicDeliver, Method},
+    queue::{Queue, QueueEvent, QueueEventReceiver},
+    GlobalData,
+};
+use std::borrow::Borrow;
+use tracing::info;
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct QueueTask {
+    global_data: GlobalData,
+    event_recv: QueueEventReceiver,
+    queue: Queue,
+}
+
+impl QueueTask {
+    fn show_name(&self) -> &str {
+        self.queue.name.borrow()
+    }
+
+    pub fn new(global_data: GlobalData, event_recv: QueueEventReceiver, queue: Queue) -> Self {
+        Self {
+            global_data,
+            event_recv,
+            queue,
+        }
+    }
+
+    #[tracing::instrument(skip(self), fields(name = self.show_name()))]
+    pub async fn start(mut self) {
+        info!("Started queue worker task");
+
+        loop {
+            let next_event = self.event_recv.recv().await;
+
+            match next_event {
+                Some(QueueEvent::PublishMessage(message)) => {
+                    self.handle_publish_message(message).await
+                }
+                Some(QueueEvent::Shutdown) | None => {
+                    self.cleanup().await;
+                    return;
+                }
+            }
+        }
+    }
+
+    #[tracing::instrument(skip(self), fields(name = self.show_name()), level = "debug")]
+    async fn handle_publish_message(&mut self, message: Message) {
+        // todo: we just send it to the consumer directly and ignore it if the consumer doesn't exist
+        // consuming is hard, but this should work *for now*
+
+        let could_deliver = {
+            let consumers = self.queue.consumers.lock();
+            if let Some(consumer) = consumers.values().next() {
+                Self::try_deliver(&message, consumer)
+            } else {
+                Err(())
+            }
+        };
+
+        if let Err(()) = could_deliver {
+            self.queue_message(message).await;
+        }
+    }
+
+    #[tracing::instrument(skip(consumer), level = "trace")]
+    fn try_deliver(message: &Message, consumer: &Consumer) -> Result<(), ()> {
+        let routing = &message.routing;
+
+        let method = Box::new(Method::BasicDeliver(BasicDeliver {
+            consumer_tag: consumer.tag.clone(),
+            delivery_tag: 0,
+            redelivered: false,
+            exchange: routing.exchange.clone(),
+            routing_key: routing.routing_key.clone(),
+        }));
+
+        let result = consumer
+            .channel
+            .event_sender
+            .try_send(ConnectionEvent::MethodContent(
+                consumer.channel.num,
+                method,
+                message.header.clone(),
+                message.content.clone(),
+            ));
+
+        result.map_err(drop)
+    }
+
+    #[tracing::instrument(skip(self), fields(name = self.show_name()), level = "trace")]
+    async fn queue_message(&mut self, _message: Message) {}
+
+    async fn cleanup(&mut self) {
+        // do stuff or something like that id whatever
+    }
+}