feat: add support for host logging, deprecating old topics_logger in favor of host-managed topics logger. updates examples.

Cargo.toml

@@ -34,4 +34,5 @@ serde_json              = { version = "1" }
 sha2                    = { version = "0" }
 tiktoken-rs             = { version = "0" }
 thiserror               = { version = "2" }
+time                    = { version = "0.3" }
 wit-bindgen             = { version = "0.41" }

momento-functions-host/src/lib.rs

@@ -16,6 +16,7 @@ pub mod aws;
 pub mod cache;
 pub mod encoding;
 pub mod http;
+pub mod logging;
 pub mod redis;
 mod spawn;
 pub mod topics;

momento-functions-host/src/logging.rs

@@ -0,0 +1,102 @@
+//! Host interfaces for working with host logging, allowing you to send
+//! logs to different destinations
+use momento_functions_wit::host::momento::host::logging;
+use thiserror::Error;
+
+/// Where do you want your logs to go?
+pub enum LogDestination {
+    /// Momento topic within the same cache as your function
+    Topic {
+        /// Name of the topic
+        topic: String,
+    },
+}
+
+/// A single configuration for a destination
+pub struct ConfigureLoggingInput {
+    /// At what level would you like Momento's system logs to be filtered into this destination?
+    pub system_log_level: log::LevelFilter,
+    /// The specific destination
+    pub destination: LogDestination,
+}
+
+impl ConfigureLoggingInput {
+    /// Constructs a single logging input with a desired destination. System logs will be at default level (INFO).
+    pub fn new(destination: LogDestination) -> Self {
+        Self {
+            system_log_level: log::LevelFilter::Info,
+            destination,
+        }
+    }
+
+    /// Constructs a single logging input with a desired destination as well as a specified system logs filter.
+    pub fn new_with_system_log_level(
+        system_log_level: log::LevelFilter,
+        destination: LogDestination,
+    ) -> Self {
+        Self {
+            system_log_level,
+            destination,
+        }
+    }
+}
+
+impl From<LogDestination> for logging::Destination {
+    fn from(value: LogDestination) -> Self {
+        match value {
+            LogDestination::Topic { topic } => {
+                momento_functions_wit::host::momento::host::logging::Destination::Topic(
+                    logging::TopicDestination { topic_name: topic },
+                )
+            }
+        }
+    }
+}
+
+impl From<ConfigureLoggingInput> for logging::ConfigureLoggingInput {
+    fn from(value: ConfigureLoggingInput) -> Self {
+        Self {
+            system_logs_level: match value.system_log_level {
+                log::LevelFilter::Off => logging::LogLevel::Off,
+                log::LevelFilter::Error => logging::LogLevel::Error,
+                log::LevelFilter::Warn => logging::LogLevel::Warn,
+                log::LevelFilter::Info => logging::LogLevel::Info,
+                log::LevelFilter::Debug => logging::LogLevel::Debug,
+                // Momento does not publish Trace logs
+                log::LevelFilter::Trace => logging::LogLevel::Debug,
+            },
+            destination: value.destination.into(),
+        }
+    }
+}
+
+/// Captures any errors Momento has detected during log configuration
+#[derive(Debug, Error)]
+pub enum LogConfigurationError {
+    #[error("Invalid auth provided for configuration! {message}")]
+    /// Invalid auth was provided
+    Auth {
+        /// The error message bubbled back up
+        message: String,
+    },
+    #[error("Something went wrong while trying to configure logs! {message}")]
+    /// Something went wrong
+    Unknown {
+        /// The error message bubbled back up
+        message: String,
+    },
+}
+
+/// Configures logging via Momento host functions
+pub fn configure_logging(inputs: Vec<ConfigureLoggingInput>) -> Result<(), LogConfigurationError> {
+    let converted: Vec<logging::ConfigureLoggingInput> =
+        inputs.into_iter().map(Into::into).collect();
+    logging::configure_logging(&converted).map_err(|e| LogConfigurationError::Auth {
+        message: e.to_string(),
+    })
+}
+
+/// Logs a given string
+pub fn log(input: &str) {
+    logging::log(input)
+}

momento-functions-log/Cargo.toml

@@ -14,3 +14,4 @@ categories.workspace = true
 log                     = { workspace = true }
 momento-functions-host  = { workspace = true }
 thiserror               = { workspace = true }
+time                    = { workspace = true, features = ["formatting"] }

momento-functions-log/src/host_logging.rs

@@ -0,0 +1,71 @@
+use std::fmt::Write;
+use std::sync::atomic::AtomicU32;
+
+use log::{LevelFilter, Log, set_logger_racy, set_max_level};
+use momento_functions_host::logging::{ConfigureLoggingInput, LogConfigurationError};
+use time::format_description::well_known::Rfc3339;
+
+pub struct HostLog {
+    level: LevelFilter,
+    dropped: AtomicU32,
+}
+
+impl HostLog {
+    pub fn init(
+        log_level: LevelFilter,
+        destinations: Vec<ConfigureLoggingInput>,
+    ) -> Result<(), LogConfigurationError> {
+        set_max_level(log_level);
+
+        static mut LOGGER: Option<HostLog> = None;
+        momento_functions_host::logging::configure_logging(destinations)?;
+        #[allow(static_mut_refs)]
+        #[allow(clippy::expect_used)]
+        unsafe {
+            LOGGER.replace(HostLog {
+                level: log_level,
+                dropped: AtomicU32::new(0),
+            });
+            set_logger_racy(LOGGER.as_mut().expect("logger just set")).map_err(|e| {
+                LogConfigurationError::Unknown {
+                    message: format!("Failed to configure logger! {e:?}"),
+                }
+            })
+        }
+    }
+}
+
+impl Log for HostLog {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        metadata.level() <= self.level
+    }
+
+    fn log(&self, record: &log::Record) {
+        if self.enabled(record.metadata()) {
+            let mut buffer = String::with_capacity(128);
+            let utc_now = time::OffsetDateTime::now_utc();
+            let timestamp = utc_now.format(&Rfc3339).unwrap_or("<unknown>".to_string());
+            let level = record.level().as_str();
+            let module = record.module_path().unwrap_or("<unknown>");
+            let file = record.file().unwrap_or("<unknown>");
+            let line = record.line().unwrap_or(0);
+            let log_message = record.args();
+
+            let dropped = self.dropped.swap(0, std::sync::atomic::Ordering::Relaxed);
+            let dropped_clause = if 0 < dropped {
+                format!(" ({dropped} messages dropped)")
+            } else {
+                String::new()
+            };
+
+            let _ = write!(
+                &mut buffer,
+                "{level} {timestamp} {module} {file}:{line}{dropped_clause} {log_message}"
+            );
+
+            momento_functions_host::logging::log(buffer.as_str());
+        }
+    }
+
+    fn flush(&self) {}
+}

momento-functions-log/src/lib.rs

@@ -11,35 +11,23 @@
 //! * [`momento-functions`](https://crates.io/crates/momento-functions): Code generators for Functions.
 //! * [`momento-functions-host`](https://crates.io/crates/momento-functions-host): Interfaces and tools for calling host interfaces.
 
-use log::SetLoggerError;
+use momento_functions_host::logging::{ConfigureLoggingInput, LogConfigurationError};
 use thiserror::Error;
 
-mod topic_logger;
-
-/// Which logging mode to use?
-pub enum LogMode {
-    Topic {
-        /// The topic to send logs to.
-        ///
-        /// You can get the logs with the `momento` CLI, or on the Momento topics dashboard at gomomento.com.
-        /// The CLI command would be `momento topic subscribe $topic`
-        /// Log messages will stream to your terminal.
-        topic: String,
-    },
-}
+mod host_logging;
 
 #[derive(Debug, Error)]
 pub enum LogConfigError {
-    #[error("Failed to initialize topics logger: {cause}")]
-    TopicsInit { cause: SetLoggerError },
+    #[error("Failed to initialize logger: {cause}")]
+    Init { cause: LogConfigurationError },
 }
 
-/// Initializes the logging system with the specified log level and mode.
+/// Initializes the logging system with the specified log level and destinations.
 ///
 /// You **must** only call this function once.
-pub fn configure_logging(level: log::LevelFilter, mode: LogMode) -> Result<(), LogConfigError> {
-    match mode {
-        LogMode::Topic { topic } => topic_logger::TopicLog::init(level, topic)
-            .map_err(|e| LogConfigError::TopicsInit { cause: e }),
-    }
+pub fn configure_logging(
+    level: log::LevelFilter,
+    destinations: Vec<ConfigureLoggingInput>,
+) -> Result<(), LogConfigError> {
+    host_logging::HostLog::init(level, destinations).map_err(|e| LogConfigError::Init { cause: e })
 }