Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use super::redis::post_message;
use crate::config::Config;
use crate::constants::DEFAULT_TIMEOUT_THRESHOLD;
use crate::context::ApiContext;
use crate::model::connection::StoredConnectionEntity;
use crate::model::message::Message;
use crate::model::sender::MessageReceipt;
use crate::service::connection::SendOutcome;
use crate::service::redis::MessageWithConnection;
use anyhow::Result;
use futures::future::join_all;
use model_entity::Entity;
use redis::aio::MultiplexedConnection;
use std::collections::HashMap;
use std::time::Instant;
pub struct Delivery {
pub user_id: String,
pub active: bool,
}
#[tracing::instrument(skip(ctx, redis_connection, message), err)]
pub async fn send_message_to_entity<Ctx>(
ctx: Ctx,
entity: &Entity<'_>,
message: Message,
redis_connection: MultiplexedConnection,
) -> Result<Vec<MessageReceipt>>
where
Ctx: AsRef<ApiContext> + AsRef<Config> + Copy,
{
tracing::trace!("sending message to entity");
let api_context: &ApiContext = ctx.as_ref();
let instant = Instant::now();
let connections = api_context
.connection_manager
.get_entries_by_entity(entity)
.await?;
tracing::trace!(
"fetched {} connections in {:?}",
connections.len(),
instant.elapsed()
);
tracing::trace!("sending message to {} connections", connections.len());
let local_connections: Vec<&StoredConnectionEntity> = connections
.iter()
.filter(|connection| {
api_context
.connection_manager
.has_connection(&connection.connection_id)
})
.collect();
let remote_connections: Vec<&StoredConnectionEntity> = connections
.iter()
.filter(|connection| {
!api_context
.connection_manager
.has_connection(&connection.connection_id)
})
.collect();
Ok(send_messages_to_connections(
api_context,
local_connections,
remote_connections,
message,
redis_connection,
)
.await)
}
#[tracing::instrument(
skip_all,
fields(
local_connection_count = local_connections.len(),
remote_connection_count = remote_connections.len(),
)
)]
async fn send_messages_to_connections(
api_context: &ApiContext,
local_connections: Vec<&StoredConnectionEntity>,
remote_connections: Vec<&StoredConnectionEntity>,
message: Message,
redis_connection: MultiplexedConnection,
) -> Vec<MessageReceipt> {
let local_send_futures = local_connections.into_iter().map(|connection| {
let message = message.clone();
async move {
let instant = Instant::now();
let active = matches!(
api_context
.connection_manager
.send_message(connection.connection_id.as_str(), message.clone())
.await,
Ok(SendOutcome::Queued)
) && connection.is_active_in_threshold(Some(DEFAULT_TIMEOUT_THRESHOLD));
tracing::trace!(
"sent message to connection directly in {:?}",
instant.elapsed()
);
let delivery = Delivery {
user_id: connection.user_id.clone(),
active,
};
Ok::<Delivery, anyhow::Error>(delivery)
}
});
let remote_send_futures = remote_connections.into_iter().map(|connection| {
let message = message.clone();
let redis_connection = redis_connection.clone();
async move {
let instant = Instant::now();
let active = connection.is_active_in_threshold(Some(DEFAULT_TIMEOUT_THRESHOLD));
post_message(
redis_connection,
MessageWithConnection {
message: message.clone(),
connection_id: connection.connection_id.clone(),
},
)
.await
.inspect_err(|e| {
tracing::error!(error=?e, "failed to publish message to redis");
})?;
tracing::trace!(
"sent message to connection through redis in {:?}",
instant.elapsed()
);
let delivery = Delivery {
user_id: connection.user_id.clone(),
active,
};
Ok::<Delivery, anyhow::Error>(delivery)
}
});
// Independent per connection, so they are joined rather than tried: one
// connection refusing a message is now an ordinary outcome (a saturated
// queue is ejected), and it must not cancel delivery to the healthy
// connections beside it or discard the receipts they produced.
let local_results = join_all(local_send_futures).await;
let remote_results = join_all(remote_send_futures).await;
let mut receipts: HashMap<String, MessageReceipt> = HashMap::new();
for delivery in local_results
.into_iter()
.chain(remote_results.into_iter())
.filter_map(std::result::Result::ok)
{
if let Some(receipt) = receipts.get_mut(&delivery.user_id) {
receipt.delivery_count += 1;
receipt.active = receipt.active || delivery.active;
} else {
receipts.insert(
delivery.user_id.clone(),
MessageReceipt {
user_id: delivery.user_id,
delivery_count: 1,
active: delivery.active,
},
);
}
}
receipts.into_values().collect()
}