Merge pull request microsoft#166411 from microsoft/cli/macos-service-monitoring

cli: add service integration for macos, observability

Author: connor4312

cli/src/bin/code/main.rs

@@ -9,6 +9,7 @@ use std::process::Command;
 use clap::Parser;
 use cli::{
 	commands::{args, tunnels, update, version, CommandContext},
+	constants::get_default_user_agent,
 	desktop, log as own_log,
 	state::LauncherPaths,
 	util::{
@@ -38,16 +39,12 @@ async fn main() -> Result<(), std::convert::Infallible> {
 
 	let core = parsed.core();
 	let context = CommandContext {
-		http: reqwest::Client::new(),
+		http: reqwest::ClientBuilder::new()
+			.user_agent(get_default_user_agent())
+			.build()
+			.unwrap(),
 		paths: LauncherPaths::new(&core.global_options.cli_data_dir).unwrap(),
-		log: own_log::Logger::new(
-			SdkTracerProvider::builder().build().tracer("codecli"),
-			if core.global_options.verbose {
-				own_log::Level::Trace
-			} else {
-				core.global_options.log.unwrap_or(own_log::Level::Info)
-			},
-		),
+		log: make_logger(core),
 		args: core.clone(),
 	};
 
@@ -111,6 +108,23 @@ async fn main() -> Result<(), std::convert::Infallible> {
 	}
 }
 
+fn make_logger(core: &args::CliCore) -> own_log::Logger {
+	let log_level = if core.global_options.verbose {
+		own_log::Level::Trace
+	} else {
+		core.global_options.log.unwrap_or(own_log::Level::Info)
+	};
+
+	let tracer = SdkTracerProvider::builder().build().tracer("codecli");
+	let mut log = own_log::Logger::new(tracer, log_level);
+	if let Some(f) = &core.global_options.log_to_file {
+		log =
+			log.tee(own_log::FileLogSink::new(log_level, f).expect("expected to make file logger"))
+	}
+
+	log
+}
+
 fn print_and_exit<E>(err: E) -> !
 where
 	E: std::fmt::Display,
@@ -143,7 +157,12 @@ async fn start_code(context: CommandContext, args: Vec<String>) -> Result<i32, A
 		.args(args)
 		.status()
 		.map(|s| s.code().unwrap_or(1))
-		.map_err(|e| wrap(e, format!("error running VS Code from {}", binary.display())))?;
+		.map_err(|e| {
+			wrap(
+				e,
+				format!("error running VS Code from {}", binary.display()),
+			)
+		})?;
 
 	Ok(code)
 }

cli/src/commands/args.rs

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-use std::fmt;
+use std::{fmt, path::PathBuf};
 
 use crate::{constants, log, options, tunnels::code_server::CodeServerArgs};
 use clap::{ArgEnum, Args, Parser, Subcommand};
@@ -394,6 +394,10 @@ pub struct GlobalOptions {
 	#[clap(long, global = true)]
 	pub verbose: bool,
 
+	/// Log to a file in addition to stdout. Used when running as a service.
+	#[clap(long, global = true, hide = true)]
+	pub log_to_file: Option<PathBuf>,
+
 	/// Log level to use.
 	#[clap(long, arg_enum, value_name = "level", global = true)]
 	pub log: Option<log::Level>,
@@ -596,6 +600,9 @@ pub enum TunnelServiceSubCommands {
 	/// Uninstalls and stops the tunnel service.
 	Uninstall,
 
+	/// Shows logs for the running service.
+	Log,
+
 	/// Internal command for running the service
 	#[clap(hide = true)]
 	InternalRun,

cli/src/commands/tunnels.rs

@@ -74,7 +74,7 @@ impl ServiceContainer for TunnelServiceContainer {
 		&mut self,
 		log: log::Logger,
 		launcher_paths: LauncherPaths,
-		shutdown_rx: mpsc::Receiver<ShutdownSignal>,
+		shutdown_rx: mpsc::UnboundedReceiver<ShutdownSignal>,
 	) -> Result<(), AnyError> {
 		let csa = (&self.args).into();
 		serve_with_csa(
@@ -116,19 +116,16 @@ pub async fn service(
 	match service_args {
 		TunnelServiceSubCommands::Install => {
 			// ensure logged in, otherwise subsequent serving will fail
-			println!("authing");
 			Auth::new(&ctx.paths, ctx.log.clone())
 				.get_credential()
 				.await?;
 
 			// likewise for license consent
-			println!("consent");
 			legal::require_consent(&ctx.paths, false)?;
 
 			let current_exe =
 				std::env::current_exe().map_err(|e| wrap(e, "could not get current exe"))?;
 
-			println!("calling register");
 			manager
 				.register(
 					current_exe,
@@ -147,6 +144,9 @@ pub async fn service(
 		TunnelServiceSubCommands::Uninstall => {
 			manager.unregister().await?;
 		}
+		TunnelServiceSubCommands::Log => {
+			manager.show_logs().await?;
+		}
 		TunnelServiceSubCommands::InternalRun => {
 			manager
 				.run(ctx.paths.clone(), TunnelServiceContainer::new(ctx.args))
@@ -239,7 +239,7 @@ async fn serve_with_csa(
 	log: Logger,
 	gateway_args: TunnelServeArgs,
 	csa: CodeServerArgs,
-	shutdown_rx: Option<mpsc::Receiver<ShutdownSignal>>,
+	shutdown_rx: Option<mpsc::UnboundedReceiver<ShutdownSignal>>,
 ) -> Result<i32, AnyError> {
 	// Intentionally read before starting the server. If the server updated and
 	// respawn is requested, the old binary will get renamed, and then
@@ -259,7 +259,7 @@ async fn serve_with_csa(
 	let shutdown_tx = if let Some(tx) = shutdown_rx {
 		tx
 	} else {
-		let (tx, rx) = mpsc::channel::<ShutdownSignal>(2);
+		let (tx, rx) = mpsc::unbounded_channel::<ShutdownSignal>();
 		if let Some(process_id) = gateway_args.parent_process_id {
 			match Pid::from_str(&process_id) {
 				Ok(pid) => {
@@ -270,7 +270,7 @@ async fn serve_with_csa(
 						while s.refresh_process(pid) {
 							sleep(Duration::from_millis(2000)).await;
 						}
-						tx.send(ShutdownSignal::ParentProcessKilled).await.ok();
+						tx.send(ShutdownSignal::ParentProcessKilled).ok();
 					});
 				}
 				Err(_) => {
@@ -280,7 +280,7 @@ async fn serve_with_csa(
 		}
 		tokio::spawn(async move {
 			tokio::signal::ctrl_c().await.ok();
-			tx.send(ShutdownSignal::CtrlC).await.ok();
+			tx.send(ShutdownSignal::CtrlC).ok();
 		});
 		rx
 	};

cli/src/state.rs

@@ -137,6 +137,11 @@ impl LauncherPaths {
 		&self.root
 	}
 
+	/// Suggested path for tunnel service logs, when using file logs
+	pub fn service_log_file(&self) -> PathBuf {
+		self.root.join("tunnel-service.log")
+	}
+
 	/// Removes the launcher data directory.
 	pub fn remove(&self) -> Result<(), WrappedError> {
 		remove_dir_all(&self.root).map_err(|e| {

cli/src/tunnels.rs

@@ -21,6 +21,8 @@ mod service;
 mod service_linux;
 #[cfg(target_os = "windows")]
 mod service_windows;
+#[cfg(target_os = "macos")]
+mod service_macos;
 
 pub use control_server::serve;
 pub use service::{

cli/src/tunnels/control_server.rs

@@ -167,7 +167,7 @@ pub async fn serve(
 	launcher_paths: &LauncherPaths,
 	code_server_args: &CodeServerArgs,
 	platform: Platform,
-	shutdown_rx: mpsc::Receiver<ShutdownSignal>,
+	shutdown_rx: mpsc::UnboundedReceiver<ShutdownSignal>,
 ) -> Result<ServerTermination, AnyError> {
 	let mut port = tunnel.add_port_direct(CONTROL_PORT).await?;
 	print_listening(log, &tunnel.name);

cli/src/tunnels/service.rs

@@ -3,15 +3,16 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use async_trait::async_trait;
 use tokio::sync::mpsc;
 
 use crate::commands::tunnels::ShutdownSignal;
 use crate::log;
 use crate::state::LauncherPaths;
-use crate::util::errors::AnyError;
+use crate::util::errors::{wrap, AnyError};
+use crate::util::io::{tailf, TailEvent};
 
 pub const SERVICE_LOG_FILE_NAME: &str = "tunnel-service.log";
 
@@ -21,7 +22,7 @@ pub trait ServiceContainer: Send {
 		&mut self,
 		log: log::Logger,
 		launcher_paths: LauncherPaths,
-		shutdown_rx: mpsc::Receiver<ShutdownSignal>,
+		shutdown_rx: mpsc::UnboundedReceiver<ShutdownSignal>,
 	) -> Result<(), AnyError>;
 }
 
@@ -40,6 +41,9 @@ pub trait ServiceManager {
 		handle: impl 'static + ServiceContainer,
 	) -> Result<(), AnyError>;
 
+	/// Show logs from the running service to standard out.
+	async fn show_logs(&self) -> Result<(), AnyError>;
+
 	/// Unregisters the current executable as a service.
 	async fn unregister(&self) -> Result<(), AnyError>;
 }
@@ -50,50 +54,42 @@ pub type ServiceManagerImpl = super::service_windows::WindowsService;
 #[cfg(target_os = "linux")]
 pub type ServiceManagerImpl = super::service_linux::SystemdService;
 
-#[cfg(not(any(target_os = "windows", target_os = "linux")))]
-pub type ServiceManagerImpl = UnimplementedServiceManager;
+#[cfg(target_os = "macos")]
+pub type ServiceManagerImpl = super::service_macos::LaunchdService;
 
 #[allow(unreachable_code)]
 #[allow(unused_variables)]
 pub fn create_service_manager(log: log::Logger, paths: &LauncherPaths) -> ServiceManagerImpl {
+	#[cfg(target_os = "macos")]
+	{
+		super::service_macos::LaunchdService::new(log, paths)
+	}
 	#[cfg(target_os = "windows")]
 	{
-		super::service_windows::WindowsService::new(log)
+		super::service_windows::WindowsService::new(log, paths)
 	}
 	#[cfg(target_os = "linux")]
 	{
 		super::service_linux::SystemdService::new(log, paths.clone())
 	}
-	#[cfg(not(any(target_os = "windows", target_os = "linux")))]
-	{
-		UnimplementedServiceManager::new()
-	}
 }
 
-pub struct UnimplementedServiceManager();
-
-#[allow(dead_code)]
-impl UnimplementedServiceManager {
-	fn new() -> Self {
-		Self()
+#[allow(dead_code)] // unused on Linux
+pub(crate) async fn tail_log_file(log_file: &Path) -> Result<(), AnyError> {
+	if !log_file.exists() {
+		println!("The tunnel service has not started yet.");
+		return Ok(());
 	}
-}
 
-#[async_trait]
-impl ServiceManager for UnimplementedServiceManager {
-	async fn register(&self, _exe: PathBuf, _args: &[&str]) -> Result<(), AnyError> {
-		unimplemented!("Service management is not supported on this platform");
-	}
-
-	async fn run(
-		self,
-		_launcher_paths: LauncherPaths,
-		_handle: impl 'static + ServiceContainer,
-	) -> Result<(), AnyError> {
-		unimplemented!("Service management is not supported on this platform");
+	let file = std::fs::File::open(log_file).map_err(|e| wrap(e, "error opening log file"))?;
+	let mut rx = tailf(file, 20);
+	while let Some(line) = rx.recv().await {
+		match line {
+			TailEvent::Line(l) => print!("{}", l),
+			TailEvent::Reset => println!("== Tunnel service restarted =="),
+			TailEvent::Err(e) => return Err(wrap(e, "error reading log file").into()),
+		}
 	}
 
-	async fn unregister(&self) -> Result<(), AnyError> {
-		unimplemented!("Service management is not supported on this platform");
-	}
+	Ok(())
 }

cli/src/tunnels/service_linux.rs

@@ -7,6 +7,7 @@ use std::{
 	fs::File,
 	io::{self, Write},
 	path::PathBuf,
+	process::Command,
 };
 
 use async_trait::async_trait;
@@ -106,15 +107,38 @@ impl ServiceManager for SystemdService {
 		launcher_paths: crate::state::LauncherPaths,
 		mut handle: impl 'static + super::ServiceContainer,
 	) -> Result<(), crate::util::errors::AnyError> {
-		let (tx, rx) = mpsc::channel::<ShutdownSignal>(1);
+		let (tx, rx) = mpsc::unbounded_channel::<ShutdownSignal>();
 		tokio::spawn(async move {
 			tokio::signal::ctrl_c().await.ok();
-			tx.send(ShutdownSignal::CtrlC).await.ok();
+			tx.send(ShutdownSignal::CtrlC).ok();
 		});
 
 		handle.run_service(self.log, launcher_paths, rx).await
 	}
 
+	async fn show_logs(&self) -> Result<(), AnyError> {
+		// show the systemctl status header...
+		Command::new("systemctl")
+			.args([
+				"--user",
+				"status",
+				"-n",
+				"0",
+				&SystemdService::service_name_string(),
+			])
+			.status()
+			.map(|s| s.code().unwrap_or(1))
+			.map_err(|e| wrap(e, "error running systemctl"))?;
+
+		// then follow log files
+		Command::new("journalctl")
+			.args(["--user", "-f", "-u", &SystemdService::service_name_string()])
+			.status()
+			.map(|s| s.code().unwrap_or(1))
+			.map_err(|e| wrap(e, "error running journalctl"))?;
+		Ok(())
+	}
+
 	async fn unregister(&self) -> Result<(), crate::util::errors::AnyError> {
 		let connection = SystemdService::connect().await?;
 		let proxy = SystemdService::proxy(&connection).await?;