From 673e5af0305b2c5a12003476e661654b88fb855d Mon Sep 17 00:00:00 2001 From: J M <2364004+Blu-J@users.noreply.github.com> Date: Fri, 13 Jan 2023 14:41:31 -0700 Subject: [PATCH] Feat/logging local (#2103) * wip: Working on sockets, but can't connect? * simplify unix socket connection * wip: Get responses back from the server at least once. * WIP: Get the sockets working' * feat: Sockets can start/ stop/ config/ properites/ uninstall * fix: Restart services * Fix: Sockets work and can stop main and not kill client * chore: Add logging to service Co-authored-by: Aiden McClelland --- libs/embassy_container_init/src/lib.rs | 43 +++++++++++ libs/embassy_container_init/src/main.rs | 9 ++- libs/js_engine/src/artifacts/loadModule.js | 10 +-- libs/js_engine/src/lib.rs | 85 +++++++++++++++++++--- 4 files changed, 131 insertions(+), 16 deletions(-) diff --git a/libs/embassy_container_init/src/lib.rs b/libs/embassy_container_init/src/lib.rs index c1684620a..d714b8e82 100644 --- a/libs/embassy_container_init/src/lib.rs +++ b/libs/embassy_container_init/src/lib.rs @@ -56,6 +56,49 @@ impl RpcMethod for RunCommand { } } +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum LogLevel { + Trace(String), + Warn(String), + Error(String), + Info(String), + Debug(String), +} +impl LogLevel { + pub fn trace(&self) { + match self { + LogLevel::Trace(x) => tracing::trace!("{}", x), + LogLevel::Warn(x) => tracing::warn!("{}", x), + LogLevel::Error(x) => tracing::error!("{}", x), + LogLevel::Info(x) => tracing::info!("{}", x), + LogLevel::Debug(x) => tracing::debug!("{}", x), + } + } +} + +#[derive(Debug, Clone, Copy)] +pub struct Log; +impl Serialize for Log { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + Serialize::serialize(Self.as_str(), serializer) + } +} +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct LogParams { + pub gid: Option, + pub level: LogLevel, +} +impl RpcMethod for Log { + type Params = LogParams; + type Response = (); + fn as_str<'a>(&'a self) -> &'a str { + "log" + } +} + #[derive(Debug, Clone, Copy)] pub struct ReadLineStdout; impl Serialize for ReadLineStdout { diff --git a/libs/embassy_container_init/src/main.rs b/libs/embassy_container_init/src/main.rs index 6612b4ec7..ea0d67343 100644 --- a/libs/embassy_container_init/src/main.rs +++ b/libs/embassy_container_init/src/main.rs @@ -6,7 +6,7 @@ use std::sync::Arc; use embassy_container_init::{ OutputParams, OutputStrategy, ProcessGroupId, ProcessId, ReadLineStderrParams, - ReadLineStdoutParams, RunCommandParams, SendSignalParams, SignalGroupParams, + ReadLineStdoutParams, RunCommandParams, SendSignalParams, SignalGroupParams, LogParams, }; use futures::StreamExt; use helpers::NonDetachingJoinHandle; @@ -28,6 +28,7 @@ enum Output { ReadLineStdout(String), ReadLineStderr(String), Output(String), + Log, Signal, SignalGroup, } @@ -37,6 +38,8 @@ enum Output { enum Input { /// Run a new command, with the args Command(RunCommandParams), + /// Want to log locall on the service rather than the eos + Log(LogParams), // /// Get a line of stdout from the command // ReadLineStdout(ReadLineStdoutParams), // /// Get a line of stderr from the command @@ -100,6 +103,10 @@ impl Handler { // Input::ReadLineStderr(ReadLineStderrParams { pid }) => { // Output::ReadLineStderr(self.read_line_stderr(pid).await?) // } + Input::Log(LogParams { gid, level }) => { + level.trace(); + Output::Log + } Input::Output(OutputParams { pid }) => Output::Output(self.output(pid).await?), Input::Signal(SendSignalParams { pid, signal }) => { self.signal(pid, signal).await?; diff --git a/libs/js_engine/src/artifacts/loadModule.js b/libs/js_engine/src/artifacts/loadModule.js index f77371fe9..6aa0e36b8 100644 --- a/libs/js_engine/src/artifacts/loadModule.js +++ b/libs/js_engine/src/artifacts/loadModule.js @@ -117,11 +117,11 @@ const createDir = ( const removeDir = ( { volumeId = requireParam("volumeId"), path = requireParam("path") } = requireParam("options"), ) => Deno.core.opAsync("remove_dir", volumeId, path); -const trace = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opSync("log_trace", whatToTrace); -const warn = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opSync("log_warn", whatToTrace); -const error = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opSync("log_error", whatToTrace); -const debug = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opSync("log_debug", whatToTrace); -const info = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opSync("log_info", whatToTrace); +const trace = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opAsync("log_trace", whatToTrace); +const warn = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opAsync("log_warn", whatToTrace); +const error = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opAsync("log_error", whatToTrace); +const debug = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opAsync("log_debug", whatToTrace); +const info = (whatToTrace = requireParam('whatToTrace')) => Deno.core.opAsync("log_info", whatToTrace); const fetch = async (url = requireParam ('url'), options = null) => { const { body, ...response } = await Deno.core.opAsync("fetch", url, options); const textValue = Promise.resolve(body); diff --git a/libs/js_engine/src/lib.rs b/libs/js_engine/src/lib.rs index 6fc414a64..9c9484e8a 100644 --- a/libs/js_engine/src/lib.rs +++ b/libs/js_engine/src/lib.rs @@ -854,8 +854,21 @@ mod fns { } #[op] - fn log_trace(state: &mut OpState, input: String) -> Result<(), AnyError> { - let ctx = state.borrow::(); + async fn log_trace(state: Rc>, input: String) -> Result<(), AnyError> { + let state = state.borrow(); + let ctx = state.borrow::().clone(); + if let Some(rpc_client) = ctx.container_rpc_client { + return rpc_client + .request( + embassy_container_init::Log, + embassy_container_init::LogParams { + gid: Some(ctx.container_process_gid), + level: embassy_container_init::LogLevel::Trace(input), + }, + ) + .await + .map_err(|e| anyhow!("{}: {:?}", e.message, e.data)); + } tracing::trace!( package_id = tracing::field::display(&ctx.package_id), run_function = tracing::field::display(&ctx.run_function), @@ -865,8 +878,21 @@ mod fns { Ok(()) } #[op] - fn log_warn(state: &mut OpState, input: String) -> Result<(), AnyError> { - let ctx = state.borrow::(); + async fn log_warn(state: Rc>, input: String) -> Result<(), AnyError> { + let state = state.borrow(); + let ctx = state.borrow::().clone(); + if let Some(rpc_client) = ctx.container_rpc_client { + return rpc_client + .request( + embassy_container_init::Log, + embassy_container_init::LogParams { + gid: Some(ctx.container_process_gid), + level: embassy_container_init::LogLevel::Warn(input), + }, + ) + .await + .map_err(|e| anyhow!("{}: {:?}", e.message, e.data)); + } tracing::warn!( package_id = tracing::field::display(&ctx.package_id), run_function = tracing::field::display(&ctx.run_function), @@ -876,8 +902,21 @@ mod fns { Ok(()) } #[op] - fn log_error(state: &mut OpState, input: String) -> Result<(), AnyError> { - let ctx = state.borrow::(); + async fn log_error(state: Rc>, input: String) -> Result<(), AnyError> { + let state = state.borrow(); + let ctx = state.borrow::().clone(); + if let Some(rpc_client) = ctx.container_rpc_client { + return rpc_client + .request( + embassy_container_init::Log, + embassy_container_init::LogParams { + gid: Some(ctx.container_process_gid), + level: embassy_container_init::LogLevel::Error(input), + }, + ) + .await + .map_err(|e| anyhow!("{}: {:?}", e.message, e.data)); + } tracing::error!( package_id = tracing::field::display(&ctx.package_id), run_function = tracing::field::display(&ctx.run_function), @@ -887,8 +926,21 @@ mod fns { Ok(()) } #[op] - fn log_debug(state: &mut OpState, input: String) -> Result<(), AnyError> { - let ctx = state.borrow::(); + async fn log_debug(state: Rc>, input: String) -> Result<(), AnyError> { + let state = state.borrow(); + let ctx = state.borrow::().clone(); + if let Some(rpc_client) = ctx.container_rpc_client { + return rpc_client + .request( + embassy_container_init::Log, + embassy_container_init::LogParams { + gid: Some(ctx.container_process_gid), + level: embassy_container_init::LogLevel::Debug(input), + }, + ) + .await + .map_err(|e| anyhow!("{}: {:?}", e.message, e.data)); + } tracing::debug!( package_id = tracing::field::display(&ctx.package_id), run_function = tracing::field::display(&ctx.run_function), @@ -898,8 +950,21 @@ mod fns { Ok(()) } #[op] - fn log_info(state: &mut OpState, input: String) -> Result<(), AnyError> { - let ctx = state.borrow::(); + async fn log_info(state: Rc>, input: String) -> Result<(), AnyError> { + let state = state.borrow(); + let ctx = state.borrow::().clone(); + if let Some(rpc_client) = ctx.container_rpc_client { + return rpc_client + .request( + embassy_container_init::Log, + embassy_container_init::LogParams { + gid: Some(ctx.container_process_gid), + level: embassy_container_init::LogLevel::Info(input), + }, + ) + .await + .map_err(|e| anyhow!("{}: {:?}", e.message, e.data)); + } tracing::info!( package_id = tracing::field::display(&ctx.package_id), run_function = tracing::field::display(&ctx.run_function),