cli: add service integration for macos, observability

Adds support for running the tunnel as a service on macOS via launchservices.

It also hooks up observability (`code tunnel service log`) on macOS and Linux.
On macOS--and later Windows, hence the manual implementation of `tail`--it
saves output to a log file and watches it. On Linux, it simply delegates to
journalctl.

The "tailing" is implemented via simple polling of the file size. I didn't want
to pull in a giant set of dependencies for inotify/kqueue/etc just for this use
case; performance when polling a single log file is not a huge concern.

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

@@ -116,13 +116,11 @@ 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 =
@@ -147,6 +145,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))

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/service.rs

@@ -40,6 +40,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,12 +53,16 @@ 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)
@@ -64,36 +71,4 @@ pub fn create_service_manager(log: log::Logger, paths: &LauncherPaths) -> Servic
 	{
 		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()
-	}
-}
-
-#[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");
-	}
-
-	async fn unregister(&self) -> Result<(), AnyError> {
-		unimplemented!("Service management is not supported on this platform");
-	}
 }

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;
@@ -115,6 +116,29 @@ impl ServiceManager for SystemdService {
 		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, format!("error running journalctl")))?;
+
+		// 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, format!("error running journalctl")))?;
+		Ok(())
+	}
+
 	async fn unregister(&self) -> Result<(), crate::util::errors::AnyError> {
 		let connection = SystemdService::connect().await?;
 		let proxy = SystemdService::proxy(&connection).await?;