feat: implement event notification system

- Add core event notification interfaces
- Support multiple notification backends:
  - Webhook (default)
  - Kafka
  - MQTT
  - HTTP Producer
- Implement configurable event filtering
- Add async event dispatching with backpressure handling
- Provide serialization/deserialization for event payloads

This module enables system events to be published to various endpoints
with consistent delivery guarantees and failure handling.

crates/event-notifier/src/adapter/kafka.rs

@@ -0,0 +1,76 @@
+use crate::ChannelAdapter;
+use crate::Error;
+use crate::Event;
+use crate::KafkaConfig;
+use async_trait::async_trait;
+use rdkafka::error::KafkaError;
+use rdkafka::producer::{FutureProducer, FutureRecord};
+use rdkafka::types::RDKafkaErrorCode;
+use rdkafka::util::Timeout;
+use std::time::Duration;
+use tokio::time::sleep;
+
+/// Kafka adapter for sending events to a Kafka topic.
+pub struct KafkaAdapter {
+    producer: FutureProducer,
+    topic: String,
+    max_retries: u32,
+}
+
+impl KafkaAdapter {
+    /// Creates a new Kafka adapter.
+    pub fn new(config: &KafkaConfig) -> Result<Self, Error> {
+        // Create a Kafka producer with the provided configuration.
+        let producer = rdkafka::config::ClientConfig::new()
+            .set("bootstrap.servers", &config.brokers)
+            .set("message.timeout.ms", config.timeout.to_string())
+            .create()?;
+
+        Ok(Self {
+            producer,
+            topic: config.topic.clone(),
+            max_retries: config.max_retries,
+        })
+    }
+    /// Sends an event to the Kafka topic with retry logic.
+    async fn send_with_retry(&self, event: &Event) -> Result<(), Error> {
+        let event_id = event.id.to_string();
+        let payload = serde_json::to_string(&event)?;
+
+        for attempt in 0..self.max_retries {
+            let record = FutureRecord::to(&self.topic)
+                .key(&event_id)
+                .payload(&payload);
+
+            match self.producer.send(record, Timeout::Never).await {
+                Ok(_) => return Ok(()),
+                Err((KafkaError::MessageProduction(RDKafkaErrorCode::QueueFull), _)) => {
+                    tracing::warn!(
+                        "Kafka attempt {} failed: Queue full. Retrying...",
+                        attempt + 1
+                    );
+                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
+                }
+                Err((e, _)) => {
+                    tracing::error!("Kafka send error: {}", e);
+                    return Err(Error::Kafka(e));
+                }
+            }
+        }
+
+        Err(Error::Custom(
+            "Exceeded maximum retry attempts for Kafka message".to_string(),
+        ))
+    }
+}
+
+#[async_trait]
+impl ChannelAdapter for KafkaAdapter {
+    fn name(&self) -> String {
+        "kafka".to_string()
+    }
+
+    async fn send(&self, event: &Event) -> Result<(), Error> {
+        self.send_with_retry(event).await
+    }
+}

crates/event-notifier/src/adapter/mod.rs

@@ -0,0 +1,54 @@
+use crate::AdapterConfig;
+use crate::Error;
+use crate::Event;
+use async_trait::async_trait;
+use std::sync::Arc;
+
+#[cfg(feature = "kafka")]
+pub(crate) mod kafka;
+#[cfg(feature = "mqtt")]
+pub(crate) mod mqtt;
+#[cfg(feature = "webhook")]
+pub(crate) mod webhook;
+
+/// The `ChannelAdapter` trait defines the interface for all channel adapters.
+#[async_trait]
+pub trait ChannelAdapter: Send + Sync + 'static {
+    /// Sends an event to the channel.
+    fn name(&self) -> String;
+    /// Sends an event to the channel.
+    async fn send(&self, event: &Event) -> Result<(), Error>;
+}
+
+/// Creates channel adapters based on the provided configuration.
+pub fn create_adapters(configs: &[AdapterConfig]) -> Result<Vec<Arc<dyn ChannelAdapter>>, Box<Error>> {
+    let mut adapters: Vec<Arc<dyn ChannelAdapter>> = Vec::new();
+
+    for config in configs {
+        match config {
+            #[cfg(feature = "webhook")]
+            AdapterConfig::Webhook(webhook_config) => {
+                webhook_config.validate().map_err(|e| Box::new(Error::ConfigError(e)))?;
+                adapters.push(Arc::new(webhook::WebhookAdapter::new(webhook_config.clone())));
+            }
+            #[cfg(feature = "kafka")]
+            AdapterConfig::Kafka(kafka_config) => {
+                adapters.push(Arc::new(kafka::KafkaAdapter::new(kafka_config)?));
+            }
+            #[cfg(feature = "mqtt")]
+            AdapterConfig::Mqtt(mqtt_config) => {
+                let (mqtt, mut event_loop) = mqtt::MqttAdapter::new(mqtt_config);
+                tokio::spawn(async move { while event_loop.poll().await.is_ok() {} });
+                adapters.push(Arc::new(mqtt));
+            }
+            #[cfg(not(feature = "webhook"))]
+            AdapterConfig::Webhook(_) => return Err(Box::new(Error::FeatureDisabled("webhook"))),
+            #[cfg(not(feature = "kafka"))]
+            AdapterConfig::Kafka(_) => return Err(Box::new(Error::FeatureDisabled("kafka"))),
+            #[cfg(not(feature = "mqtt"))]
+            AdapterConfig::Mqtt(_) => return Err(Box::new(Error::FeatureDisabled("mqtt"))),
+        }
+    }
+
+    Ok(adapters)
+}

crates/event-notifier/src/adapter/mqtt.rs

@@ -0,0 +1,58 @@
+use crate::ChannelAdapter;
+use crate::Error;
+use crate::Event;
+use crate::MqttConfig;
+use async_trait::async_trait;
+use rumqttc::{AsyncClient, MqttOptions, QoS};
+use std::time::Duration;
+use tokio::time::sleep;
+
+/// MQTT adapter for sending events to an MQTT broker.
+pub struct MqttAdapter {
+    client: AsyncClient,
+    topic: String,
+    max_retries: u32,
+}
+
+impl MqttAdapter {
+    /// Creates a new MQTT adapter.
+    pub fn new(config: &MqttConfig) -> (Self, rumqttc::EventLoop) {
+        let mqtt_options = MqttOptions::new(&config.client_id, &config.broker, config.port);
+        let (client, event_loop) = rumqttc::AsyncClient::new(mqtt_options, 10);
+        (
+            Self {
+                client,
+                topic: config.topic.clone(),
+                max_retries: config.max_retries,
+            },
+            event_loop,
+        )
+    }
+}
+
+#[async_trait]
+impl ChannelAdapter for MqttAdapter {
+    fn name(&self) -> String {
+        "mqtt".to_string()
+    }
+
+    async fn send(&self, event: &Event) -> Result<(), Error> {
+        let payload = serde_json::to_string(event).map_err(Error::Serde)?;
+        let mut attempt = 0;
+        loop {
+            match self
+                .client
+                .publish(&self.topic, QoS::AtLeastOnce, false, payload.clone())
+                .await
+            {
+                Ok(()) => return Ok(()),
+                Err(e) if attempt < self.max_retries => {
+                    attempt += 1;
+                    tracing::warn!("MQTT attempt {} failed: {}. Retrying...", attempt, e);
+                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
+                }
+                Err(e) => return Err(Error::Mqtt(e)),
+            }
+        }
+    }
+}

crates/event-notifier/src/adapter/webhook.rs

@@ -0,0 +1,63 @@
+use crate::ChannelAdapter;
+use crate::Error;
+use crate::Event;
+use crate::WebhookConfig;
+use async_trait::async_trait;
+use reqwest::{Client, RequestBuilder};
+use std::time::Duration;
+use tokio::time::sleep;
+
+/// Webhook adapter for sending events to a webhook endpoint.
+pub struct WebhookAdapter {
+    config: WebhookConfig,
+    client: Client,
+}
+
+impl WebhookAdapter {
+    /// Creates a new Webhook adapter.
+    pub fn new(config: WebhookConfig) -> Self {
+        let client = Client::builder()
+            .timeout(Duration::from_secs(config.timeout))
+            .build()
+            .expect("Failed to build reqwest client");
+        Self { config, client }
+    }
+    /// Builds the request to send the event.
+    fn build_request(&self, event: &Event) -> RequestBuilder {
+        let mut request = self.client.post(&self.config.endpoint).json(event);
+        if let Some(token) = &self.config.auth_token {
+            request = request.header("Authorization", format!("Bearer {}", token));
+        }
+        if let Some(headers) = &self.config.custom_headers {
+            for (key, value) in headers {
+                request = request.header(key, value);
+            }
+        }
+        request
+    }
+}
+
+#[async_trait]
+impl ChannelAdapter for WebhookAdapter {
+    fn name(&self) -> String {
+        "webhook".to_string()
+    }
+
+    async fn send(&self, event: &Event) -> Result<(), Error> {
+        let mut attempt = 0;
+        loop {
+            match self.build_request(event).send().await {
+                Ok(response) => {
+                    response.error_for_status().map_err(Error::Http)?;
+                    return Ok(());
+                }
+                Err(e) if attempt < self.config.max_retries => {
+                    attempt += 1;
+                    tracing::warn!("Webhook attempt {} failed: {}. Retrying...", attempt, e);
+                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
+                }
+                Err(e) => return Err(Error::Http(e)),
+            }
+        }
+    }
+}