From 90f8a90ae2dfbd6e943ff19e3c7441e73030a7e3 Mon Sep 17 00:00:00 2001 From: Vim Wickramasinghe Date: Mon, 4 May 2026 16:16:27 +0200 Subject: [PATCH] Remove debug logging from OpenTelemetry sdk --- crates/tower-cmd/src/api.rs | 17 +++---- crates/tower-cmd/src/apps.rs | 38 ++++++++++++---- crates/tower-cmd/src/deploy.rs | 7 ++- crates/tower-cmd/src/mcp.rs | 28 +++++++----- crates/tower-cmd/src/run.rs | 30 +++++++++---- crates/tower-cmd/src/schedules.rs | 8 +++- crates/tower-cmd/src/secrets.rs | 9 ++-- crates/tower-cmd/src/session.rs | 3 +- crates/tower-cmd/src/skill.rs | 17 ++----- crates/tower-cmd/src/teams.rs | 5 ++- crates/tower-cmd/src/util/deploy.rs | 12 +++-- crates/tower-package/src/core.rs | 30 +++++++++---- crates/tower-package/src/native.rs | 18 ++++++-- crates/tower-package/src/towerfile.rs | 52 +++++++++++++--------- crates/tower-package/src/wasm.rs | 6 +-- crates/tower-package/tests/package_test.rs | 39 +++++++++++----- crates/tower-runtime/src/lib.rs | 5 ++- crates/tower-telemetry/src/logging.rs | 9 +++- 18 files changed, 212 insertions(+), 121 deletions(-) diff --git a/crates/tower-cmd/src/api.rs b/crates/tower-cmd/src/api.rs index 0297bf11..8f0956b6 100644 --- a/crates/tower-cmd/src/api.rs +++ b/crates/tower-cmd/src/api.rs @@ -404,10 +404,8 @@ pub async fn refresh_session( pub async fn list_teams( config: &Config, -) -> Result< - tower_api::models::ListTeamsResponse, - Error, -> { +) -> Result> +{ let api_config = &config.into(); let params = tower_api::apis::default_api::ListTeamsParams { @@ -1079,10 +1077,8 @@ pub async fn cancel_run( config: &Config, name: &str, seq: i64, -) -> Result< - tower_api::models::CancelRunResponse, - Error, -> { +) -> Result> +{ let api_config = &config.into(); let params = tower_api::apis::default_api::CancelRunParams { @@ -1090,10 +1086,7 @@ pub async fn cancel_run( seq, }; - unwrap_api_response(tower_api::apis::default_api::cancel_run( - api_config, params, - )) - .await + unwrap_api_response(tower_api::apis::default_api::cancel_run(api_config, params)).await } impl ResponseEntity for tower_api::apis::default_api::CancelRunSuccess { diff --git a/crates/tower-cmd/src/apps.rs b/crates/tower-cmd/src/apps.rs index ab632620..c6210dab 100644 --- a/crates/tower-cmd/src/apps.rs +++ b/crates/tower-cmd/src/apps.rs @@ -97,9 +97,13 @@ pub fn apps_cmd() -> Command { } pub async fn do_logs(config: Config, cmd: &ArgMatches) { - let app_name_raw = cmd.get_one::("app_name").expect("app_name is required"); + let app_name_raw = cmd + .get_one::("app_name") + .expect("app_name is required"); let (name, seq) = if let Some((name, num_str)) = app_name_raw.split_once('#') { - let num = num_str.parse::().unwrap_or_else(|_| output::die("Run number must be a number")); + let num = num_str + .parse::() + .unwrap_or_else(|_| output::die("Run number must be a number")); (name.to_string(), num) } else { let num = match cmd.get_one::("run_number").copied() { @@ -123,7 +127,9 @@ pub async fn do_logs(config: Config, cmd: &ArgMatches) { } pub async fn do_show(config: Config, cmd: &ArgMatches) { - let name = cmd.get_one::("app_name").expect("app_name is required"); + let name = cmd + .get_one::("app_name") + .expect("app_name is required"); match api::describe_app(&config, &name).await { Ok(app_response) => { @@ -236,7 +242,9 @@ pub async fn do_create(config: Config, args: &ArgMatches) { } pub async fn do_delete(config: Config, cmd: &ArgMatches) { - let name = cmd.get_one::("app_name").expect("app_name is required"); + let name = cmd + .get_one::("app_name") + .expect("app_name is required"); output::with_spinner("Deleting app", api::delete_app(&config, name)).await; } @@ -263,7 +271,8 @@ pub async fn do_cancel(config: Config, cmd: &ArgMatches) { async fn latest_run_number(config: &Config, name: &str) -> i64 { match api::describe_app(config, name).await { - Ok(resp) => resp.runs + Ok(resp) => resp + .runs .iter() .map(|r| r.number) .max() @@ -307,7 +316,9 @@ async fn follow_logs(config: Config, name: String, seq: i64) { sleep(RUN_START_POLL_INTERVAL).await; if wait_started.elapsed() > RUN_START_TIMEOUT { - output::error("Timed out waiting for run to start. The runner may be unavailable."); + output::error( + "Timed out waiting for run to start. The runner may be unavailable.", + ); return; } @@ -585,7 +596,9 @@ mod tests { assert_eq!(cmd, "logs"); assert_eq!(sub_matches.get_one::("follow"), Some(&true)); assert_eq!( - sub_matches.get_one::("app_name").map(|s| s.as_str()), + sub_matches + .get_one::("app_name") + .map(|s| s.as_str()), Some("hello-world#11") ); assert_eq!(sub_matches.get_one::("run_number"), None); @@ -599,7 +612,9 @@ mod tests { let (_, sub_matches) = matches.subcommand().unwrap(); assert_eq!( - sub_matches.get_one::("app_name").map(|s| s.as_str()), + sub_matches + .get_one::("app_name") + .map(|s| s.as_str()), Some("hello-world") ); assert_eq!(sub_matches.get_one::("run_number"), Some(&11)); @@ -607,7 +622,12 @@ mod tests { #[test] fn test_terminal_statuses_explicit() { - let non_terminal = [Status::Scheduled, Status::Pending, Status::Running, Status::Retrying]; + let non_terminal = [ + Status::Scheduled, + Status::Pending, + Status::Running, + Status::Retrying, + ]; for status in non_terminal { let run = Run { status, diff --git a/crates/tower-cmd/src/deploy.rs b/crates/tower-cmd/src/deploy.rs index 069c1ca9..c5328f38 100644 --- a/crates/tower-cmd/src/deploy.rs +++ b/crates/tower-cmd/src/deploy.rs @@ -106,12 +106,11 @@ pub async fn deploy_from_dir( let path = dir.join("Towerfile"); let path_display = path.display().to_string(); - let towerfile = Towerfile::from_path(path).map_err(|source| { - crate::Error::TowerfileLoadFailed { + let towerfile = + Towerfile::from_path(path).map_err(|source| crate::Error::TowerfileLoadFailed { path: path_display, source, - } - })?; + })?; let api_config = config.into(); // Add app existence check before proceeding diff --git a/crates/tower-cmd/src/mcp.rs b/crates/tower-cmd/src/mcp.rs index d46ba454..0b069356 100644 --- a/crates/tower-cmd/src/mcp.rs +++ b/crates/tower-cmd/src/mcp.rs @@ -859,12 +859,15 @@ impl TowerService { } let name = request.name.clone(); Self::modify_towerfile(&request.common, |tf| { - tf.set_parameter(&name, Parameter { - name: name.clone(), - description: request.description.unwrap_or_default(), - default: request.default.unwrap_or_default(), - hidden: request.hidden, - }); + tf.set_parameter( + &name, + Parameter { + name: name.clone(), + description: request.description.unwrap_or_default(), + default: request.default.unwrap_or_default(), + hidden: request.hidden, + }, + ); Ok(format!("Added parameter '{name}'")) }) } @@ -878,7 +881,10 @@ impl TowerService { ) -> Result { let name = request.name.clone(); Self::modify_towerfile(&request.common, |tf| { - let existing = tf.parameters.iter().find(|p| p.name == name) + let existing = tf + .parameters + .iter() + .find(|p| p.name == name) .ok_or_else(|| format!("Parameter '{name}' not found"))?; let target_name = request .new_name @@ -889,7 +895,9 @@ impl TowerService { } let param = Parameter { name: target_name, - description: request.description.unwrap_or_else(|| existing.description.clone()), + description: request + .description + .unwrap_or_else(|| existing.description.clone()), default: request.default.unwrap_or_else(|| existing.default.clone()), hidden: request.hidden.unwrap_or(existing.hidden), }; @@ -901,9 +909,7 @@ impl TowerService { }) } - #[tool( - description = "Remove a parameter from the Towerfile. Optional: working_directory." - )] + #[tool(description = "Remove a parameter from the Towerfile. Optional: working_directory.")] async fn tower_file_remove_parameter( &self, Parameters(request): Parameters, diff --git a/crates/tower-cmd/src/run.rs b/crates/tower-cmd/src/run.rs index 64f6cd5d..9ad5a189 100644 --- a/crates/tower-cmd/src/run.rs +++ b/crates/tower-cmd/src/run.rs @@ -107,10 +107,7 @@ pub async fn do_run(config: Config, args: &ArgMatches) { /// do_run is the primary entrypoint into running apps both locally and remotely in Tower. It will /// use the configuration to determine the requested way of running a Tower app. -pub async fn do_run_inner( - config: Config, - args: &ArgMatches, -) -> Result<(), Error> { +pub async fn do_run_inner(config: Config, args: &ArgMatches) -> Result<(), Error> { let res = get_run_parameters(args); // We always expect there to be an environment due to the fact that there is a @@ -855,7 +852,10 @@ mod tests { #[test] fn app_name_parsed_as_positional_arg() { let m = parse(&["my-app"]).unwrap(); - assert_eq!(m.get_one::("app_name").map(|s| s.as_str()), Some("my-app")); + assert_eq!( + m.get_one::("app_name").map(|s| s.as_str()), + Some("my-app") + ); } #[test] @@ -868,8 +868,14 @@ mod tests { fn unknown_flags_are_rejected() { let err = parse(&["--param", "x=y"]).unwrap_err(); let msg = err.to_string(); - assert!(msg.contains("--param"), "should mention the bad flag: {msg}"); - assert!(msg.contains("--parameter"), "should suggest the correct flag: {msg}"); + assert!( + msg.contains("--param"), + "should mention the bad flag: {msg}" + ); + assert!( + msg.contains("--parameter"), + "should suggest the correct flag: {msg}" + ); } #[test] @@ -887,7 +893,10 @@ mod tests { #[test] fn parameters_after_app_name() { let m = parse(&["my-app", "-p", "key=val"]).unwrap(); - assert_eq!(m.get_one::("app_name").map(|s| s.as_str()), Some("my-app")); + assert_eq!( + m.get_one::("app_name").map(|s| s.as_str()), + Some("my-app") + ); let params: Vec<&String> = m.get_many::("parameters").unwrap().collect(); assert_eq!(params, vec!["key=val"]); } @@ -895,7 +904,10 @@ mod tests { #[test] fn parameters_before_app_name() { let m = parse(&["-p", "key=val", "my-app"]).unwrap(); - assert_eq!(m.get_one::("app_name").map(|s| s.as_str()), Some("my-app")); + assert_eq!( + m.get_one::("app_name").map(|s| s.as_str()), + Some("my-app") + ); let params: Vec<&String> = m.get_many::("parameters").unwrap().collect(); assert_eq!(params, vec!["key=val"]); } diff --git a/crates/tower-cmd/src/schedules.rs b/crates/tower-cmd/src/schedules.rs index 59562cf2..cb6aa499 100644 --- a/crates/tower-cmd/src/schedules.rs +++ b/crates/tower-cmd/src/schedules.rs @@ -171,7 +171,9 @@ pub async fn do_create(config: Config, args: &ArgMatches) { } pub async fn do_update(config: Config, args: &ArgMatches) { - let id_or_name = args.get_one::("id_or_name").expect("id_or_name is required"); + let id_or_name = args + .get_one::("id_or_name") + .expect("id_or_name is required"); let cron = args.get_one::("cron"); let parameters = parse_parameters(args); @@ -185,7 +187,9 @@ pub async fn do_update(config: Config, args: &ArgMatches) { } pub async fn do_delete(config: Config, args: &ArgMatches) { - let schedule_id = args.get_one::("schedule_id").expect("schedule_id is required"); + let schedule_id = args + .get_one::("schedule_id") + .expect("schedule_id is required"); output::with_spinner( "Deleting schedule", diff --git a/crates/tower-cmd/src/secrets.rs b/crates/tower-cmd/src/secrets.rs index e6a95393..f6baf5bd 100644 --- a/crates/tower-cmd/src/secrets.rs +++ b/crates/tower-cmd/src/secrets.rs @@ -185,11 +185,15 @@ pub async fn do_create(config: Config, args: &ArgMatches) { } pub async fn do_delete(config: Config, args: &ArgMatches) { - let secret_name_arg = args.get_one::("secret_name").expect("secret_name is required"); + let secret_name_arg = args + .get_one::("secret_name") + .expect("secret_name is required"); let (environment, name) = if let Some((env, name)) = secret_name_arg.split_once('/') { (env.to_string(), name.to_string()) } else { - let env = args.get_one::("environment").expect("environment has default"); + let env = args + .get_one::("environment") + .expect("environment has default"); (env.clone(), secret_name_arg.clone()) }; debug!("deleting secret, environment={} name={}", environment, name); @@ -240,4 +244,3 @@ async fn encrypt_and_create_secret( .await .map_err(SecretCreationError::CreateFailed) } - diff --git a/crates/tower-cmd/src/session.rs b/crates/tower-cmd/src/session.rs index 409d06cd..32d88987 100644 --- a/crates/tower-cmd/src/session.rs +++ b/crates/tower-cmd/src/session.rs @@ -33,7 +33,8 @@ pub async fn do_login(config: Config, args: &ArgMatches) { eprint!("Do you want to continue? [y/N] "); let mut input = String::new(); - if std::io::stdin().read_line(&mut input).is_err() || !input.trim().eq_ignore_ascii_case("y") + if std::io::stdin().read_line(&mut input).is_err() + || !input.trim().eq_ignore_ascii_case("y") { return; } diff --git a/crates/tower-cmd/src/skill.rs b/crates/tower-cmd/src/skill.rs index 13caca60..be1ee7b7 100644 --- a/crates/tower-cmd/src/skill.rs +++ b/crates/tower-cmd/src/skill.rs @@ -29,10 +29,7 @@ fn generate_skill_md(root: Command) -> String { } fn append_command(out: &mut String, cmd: &Command, path: &[&str], depth: usize) { - let subcommands: Vec<_> = cmd - .get_subcommands() - .filter(|c| !c.is_hide_set()) - .collect(); + let subcommands: Vec<_> = cmd.get_subcommands().filter(|c| !c.is_hide_set()).collect(); for sub in &subcommands { let name = sub.get_name(); @@ -71,12 +68,7 @@ fn append_command(out: &mut String, cmd: &Command, path: &[&str], depth: usize) .get_help() .map(|h| format!(" — {}", h)) .unwrap_or_default(); - out.push_str(&format!( - "- `<{}>` {}{}\n", - arg.get_id(), - req, - help - )); + out.push_str(&format!("- `<{}>` {}{}\n", arg.get_id(), req, help)); } for arg in &named { let long = arg.get_long().unwrap(); @@ -98,10 +90,7 @@ fn append_command(out: &mut String, cmd: &Command, path: &[&str], depth: usize) out.push('\n'); } - let child_subs: Vec<_> = sub - .get_subcommands() - .filter(|c| !c.is_hide_set()) - .collect(); + let child_subs: Vec<_> = sub.get_subcommands().filter(|c| !c.is_hide_set()).collect(); if !child_subs.is_empty() { append_command(out, sub, &full_path, depth + 1); diff --git a/crates/tower-cmd/src/teams.rs b/crates/tower-cmd/src/teams.rs index d0cc2413..abeaa666 100644 --- a/crates/tower-cmd/src/teams.rs +++ b/crates/tower-cmd/src/teams.rs @@ -109,7 +109,9 @@ async fn do_list_via_session(config: &Config) { } pub async fn do_switch(config: Config, args: &ArgMatches) { - let name = args.get_one::("team_name").expect("team_name is required"); + let name = args + .get_one::("team_name") + .expect("team_name is required"); // Refresh the session first to ensure we have the latest teams data let session = refresh_session(&config).await; @@ -140,4 +142,3 @@ pub async fn do_switch(config: Config, args: &ArgMatches) { } } } - diff --git a/crates/tower-cmd/src/util/deploy.rs b/crates/tower-cmd/src/util/deploy.rs index 5a6d3619..23c56a3c 100644 --- a/crates/tower-cmd/src/util/deploy.rs +++ b/crates/tower-cmd/src/util/deploy.rs @@ -8,8 +8,8 @@ use tower_package::{compute_sha256_file, Package}; use tower_telemetry::debug; use tower_api::apis::configuration::Configuration; -use tower_api::apis::urlencode; use tower_api::apis::default_api::DeployAppError; +use tower_api::apis::urlencode; use tower_api::apis::Error; use tower_api::apis::ResponseContent; use tower_api::models::DeployAppResponse; @@ -122,10 +122,16 @@ pub async fn deploy_app_package( let encoded_app_name = urlencode(app_name); let url = if all_environments { - format!("{}/apps/{}/deploy?all_environments=true", base_url, encoded_app_name) + format!( + "{}/apps/{}/deploy?all_environments=true", + base_url, encoded_app_name + ) } else if let Some(env) = environment { let encoded_environment = urlencode(env); - format!("{}/apps/{}/deploy?environment={}", base_url, encoded_app_name, encoded_environment) + format!( + "{}/apps/{}/deploy?environment={}", + base_url, encoded_app_name, encoded_environment + ) } else { format!("{}/apps/{}/deploy", base_url, encoded_app_name) }; diff --git a/crates/tower-package/src/core.rs b/crates/tower-package/src/core.rs index ed35e264..b376f83a 100644 --- a/crates/tower-package/src/core.rs +++ b/crates/tower-package/src/core.rs @@ -124,11 +124,10 @@ pub struct BuiltPackage { // normalized (mtime/uid/gid zero, mode 0644) so the output is byte-deterministic for a given // input. pub fn build_package(inputs: PackageInputs) -> Result { - let towerfile_str = std::str::from_utf8(&inputs.towerfile_bytes).map_err(|e| { - Error::InvalidTowerfile { + let towerfile_str = + std::str::from_utf8(&inputs.towerfile_bytes).map_err(|e| Error::InvalidTowerfile { message: format!("Towerfile is not valid UTF-8: {}", e), - } - })?; + })?; let towerfile = Towerfile::from_toml(towerfile_str)?; let import_paths: Vec = towerfile @@ -138,14 +137,18 @@ pub fn build_package(inputs: PackageInputs) -> Result { .map(|p| format!("modules/{}", import_path_basename(&p.to_string_lossy()))) .collect(); - let mut entries: Vec = Vec::with_capacity(inputs.app_files.len() + inputs.module_files.len()); + let mut entries: Vec = + Vec::with_capacity(inputs.app_files.len() + inputs.module_files.len()); entries.extend(inputs.app_files); entries.extend(inputs.module_files); entries.sort_by(|a, b| a.archive_name.cmp(&b.archive_name)); let mut path_hashes: HashMap = HashMap::with_capacity(entries.len()); for entry in &entries { - path_hashes.insert(entry.archive_name.clone(), compute_sha256_bytes(&entry.bytes)); + path_hashes.insert( + entry.archive_name.clone(), + compute_sha256_bytes(&entry.bytes), + ); } let manifest = Manifest { @@ -256,15 +259,24 @@ mod test { .join("path") .join("to") .join("file.txt"); - assert_eq!(normalize_path(&path).unwrap(), "some/nested/path/to/file.txt"); + assert_eq!( + normalize_path(&path).unwrap(), + "some/nested/path/to/file.txt" + ); } #[test] fn test_build_package_is_deterministic() { let inputs = || PackageInputs { app_files: vec![ - Entry { archive_name: "app/b.py".into(), bytes: b"b".to_vec() }, - Entry { archive_name: "app/a.py".into(), bytes: b"a".to_vec() }, + Entry { + archive_name: "app/b.py".into(), + bytes: b"b".to_vec(), + }, + Entry { + archive_name: "app/a.py".into(), + bytes: b"a".to_vec(), + }, ], module_files: vec![], towerfile_bytes: b"[app]\nname = \"x\"\nscript = \"app/a.py\"\n".to_vec(), diff --git a/crates/tower-package/src/native.rs b/crates/tower-package/src/native.rs index e7a6d69a..0db79b38 100644 --- a/crates/tower-package/src/native.rs +++ b/crates/tower-package/src/native.rs @@ -150,7 +150,10 @@ impl Package { let archive_path = app_dir.join(logical_path); let archive_name = normalize_path(&archive_path)?; let bytes = tokio::fs::read(&physical_path).await?; - app_files.push(Entry { archive_name, bytes }); + app_files.push(Entry { + archive_name, + bytes, + }); } // Resolve modules. Archive names use the raw import_path basename so they stay in sync @@ -158,9 +161,13 @@ impl Package { let module_dir = PathBuf::from("modules"); let mut module_files: Vec = Vec::new(); - for (raw_import, canonical_import) in spec.import_paths.iter().zip(canonical_import_paths.iter()) { + for (raw_import, canonical_import) in + spec.import_paths.iter().zip(canonical_import_paths.iter()) + { let mut module_file_paths: HashMap = HashMap::new(); - resolver.resolve_path(canonical_import, &mut module_file_paths).await; + resolver + .resolve_path(canonical_import, &mut module_file_paths) + .await; let raw_basename = Path::new(raw_import) .file_name() @@ -175,7 +182,10 @@ impl Package { }; let archive_name = normalize_path(&archive_prefix.join(rel))?; let bytes = tokio::fs::read(&physical_path).await?; - module_files.push(Entry { archive_name, bytes }); + module_files.push(Entry { + archive_name, + bytes, + }); } } diff --git a/crates/tower-package/src/towerfile.rs b/crates/tower-package/src/towerfile.rs index e0de3b29..f86b2d53 100644 --- a/crates/tower-package/src/towerfile.rs +++ b/crates/tower-package/src/towerfile.rs @@ -134,9 +134,10 @@ impl Towerfile { use crate::error::Error as OuterError; let target_path = path.unwrap_or_else(|| std::path::Path::new("Towerfile")); - let serialized = toml::to_string_pretty(self).map_err(|err| OuterError::InvalidTowerfile { - message: err.to_string(), - })?; + let serialized = + toml::to_string_pretty(self).map_err(|err| OuterError::InvalidTowerfile { + message: err.to_string(), + })?; std::fs::write(target_path, serialized).map_err(|source| OuterError::Io { source })?; Ok(()) } @@ -315,12 +316,15 @@ mod test { let mut towerfile = crate::Towerfile::default(); assert_eq!(towerfile.parameters.len(), 0); - towerfile.set_parameter("test-param", crate::Parameter { - name: "test-param".to_string(), - description: "A test parameter".to_string(), - default: "default-value".to_string(), - hidden: false, - }); + towerfile.set_parameter( + "test-param", + crate::Parameter { + name: "test-param".to_string(), + description: "A test parameter".to_string(), + default: "default-value".to_string(), + hidden: false, + }, + ); assert_eq!(towerfile.parameters.len(), 1); assert_eq!(towerfile.parameters[0].name, "test-param"); @@ -329,12 +333,15 @@ mod test { assert!(!towerfile.parameters[0].hidden); // upsert should replace, not duplicate - towerfile.set_parameter("test-param", crate::Parameter { - name: "test-param".to_string(), - description: "Updated".to_string(), - default: "new-value".to_string(), - hidden: false, - }); + towerfile.set_parameter( + "test-param", + crate::Parameter { + name: "test-param".to_string(), + description: "Updated".to_string(), + default: "new-value".to_string(), + hidden: false, + }, + ); assert_eq!(towerfile.parameters.len(), 1); assert_eq!(towerfile.parameters[0].description, "Updated"); @@ -343,12 +350,15 @@ mod test { #[test] fn test_remove_parameter() { let mut towerfile = crate::Towerfile::default(); - towerfile.set_parameter("param1", crate::Parameter { - name: "param1".to_string(), - description: "".to_string(), - default: "".to_string(), - hidden: false, - }); + towerfile.set_parameter( + "param1", + crate::Parameter { + name: "param1".to_string(), + description: "".to_string(), + default: "".to_string(), + hidden: false, + }, + ); assert!(towerfile.remove_parameter("param1")); assert_eq!(towerfile.parameters.len(), 0); diff --git a/crates/tower-package/src/wasm.rs b/crates/tower-package/src/wasm.rs index 0649f327..219fbd3d 100644 --- a/crates/tower-package/src/wasm.rs +++ b/crates/tower-package/src/wasm.rs @@ -1,5 +1,5 @@ -use serde::Deserialize; use crate::core::{build_package, Entry, PackageInputs}; +use serde::Deserialize; use wasm_bindgen::prelude::*; #[derive(Deserialize)] @@ -52,7 +52,7 @@ pub fn build_package_wasm(inputs: JsValue) -> Result, JsError> { towerfile_bytes: js.towerfile_bytes.into_vec(), }; - let built = build_package(core_inputs) - .map_err(|e| JsError::new(&format!("build failed: {}", e)))?; + let built = + build_package(core_inputs).map_err(|e| JsError::new(&format!("build failed: {}", e)))?; Ok(built.bytes) } diff --git a/crates/tower-package/tests/package_test.rs b/crates/tower-package/tests/package_test.rs index 2eeef5c1..e39a020f 100644 --- a/crates/tower-package/tests/package_test.rs +++ b/crates/tower-package/tests/package_test.rs @@ -259,12 +259,14 @@ async fn it_packages_import_paths() { ); // Let's decode the manifest and make sure import paths are set correctly. - let manifest = Manifest::from_json(files.get("MANIFEST").unwrap()) - .expect("Manifest was not valid JSON"); + let manifest = + Manifest::from_json(files.get("MANIFEST").unwrap()).expect("Manifest was not valid JSON"); // Archive paths are always normalized to forward slashes regardless of OS. assert!( - manifest.import_paths.contains(&"modules/shared".to_string()), + manifest + .import_paths + .contains(&"modules/shared".to_string()), "Import paths {:?} did not contain expected path", manifest.import_paths ); @@ -323,11 +325,13 @@ async fn it_packages_import_paths_nested_within_base_dir() { ); // Verify the manifest import_paths entry matches the actual package structure. - let manifest = Manifest::from_json(files.get("MANIFEST").unwrap()) - .expect("Manifest was not valid JSON"); + let manifest = + Manifest::from_json(files.get("MANIFEST").unwrap()).expect("Manifest was not valid JSON"); assert!( - manifest.import_paths.contains(&"modules/shared".to_string()), + manifest + .import_paths + .contains(&"modules/shared".to_string()), "Import paths {:?} did not contain expected path modules/shared", manifest.import_paths ); @@ -425,7 +429,12 @@ async fn it_includes_subapp_towerfiles_but_excludes_root_towerfile() { create_test_file(tmp_dir.to_path_buf(), "main.py", "print('Hello, world!')").await; // Sub-app with its own Towerfile - create_test_file(tmp_dir.to_path_buf(), "subapp/Towerfile", "[app]\nname = \"subapp\"").await; + create_test_file( + tmp_dir.to_path_buf(), + "subapp/Towerfile", + "[app]\nname = \"subapp\"", + ) + .await; create_test_file(tmp_dir.to_path_buf(), "subapp/main.py", "print('subapp')").await; let spec = PackageSpec { @@ -506,15 +515,23 @@ hidden = true let package = Package::build(spec).await.expect("Failed to build package"); let files = read_package_files(package).await; - let manifest = Manifest::from_json(files.get("MANIFEST").unwrap()) - .expect("Manifest was not valid JSON"); + let manifest = + Manifest::from_json(files.get("MANIFEST").unwrap()).expect("Manifest was not valid JSON"); assert_eq!(manifest.parameters.len(), 2); - let visible = manifest.parameters.iter().find(|p| p.name == "visible_param").unwrap(); + let visible = manifest + .parameters + .iter() + .find(|p| p.name == "visible_param") + .unwrap(); assert!(!visible.hidden, "visible_param should not be hidden"); - let hidden = manifest.parameters.iter().find(|p| p.name == "hidden_param").unwrap(); + let hidden = manifest + .parameters + .iter() + .find(|p| p.name == "hidden_param") + .unwrap(); assert!(hidden.hidden, "hidden_param should be hidden"); assert_eq!(hidden.default, "secret"); } diff --git a/crates/tower-runtime/src/lib.rs b/crates/tower-runtime/src/lib.rs index 6ebbb061..1be53ce8 100644 --- a/crates/tower-runtime/src/lib.rs +++ b/crates/tower-runtime/src/lib.rs @@ -56,7 +56,10 @@ pub enum Status { impl Status { /// Returns true if this status represents a terminal state (run is finished) pub fn is_terminal(&self) -> bool { - matches!(self, Status::Exited | Status::Crashed { .. } | Status::Failed { .. }) + matches!( + self, + Status::Exited | Status::Crashed { .. } | Status::Failed { .. } + ) } } diff --git a/crates/tower-telemetry/src/logging.rs b/crates/tower-telemetry/src/logging.rs index 021e9cb9..1b717f70 100644 --- a/crates/tower-telemetry/src/logging.rs +++ b/crates/tower-telemetry/src/logging.rs @@ -179,7 +179,11 @@ fn should_use_color(destination: &LogDestination) -> bool { } } -fn create_fmt_layer(level: &LogLevel, format: LogFormat, destination: LogDestination) -> BoxedFmtLayer { +fn create_fmt_layer( + level: &LogLevel, + format: LogFormat, + destination: LogDestination, +) -> BoxedFmtLayer { let use_color = should_use_color(&destination); let with_target = *level < LogLevel::Warn; @@ -242,7 +246,8 @@ pub fn enable_logging(level: LogLevel, format: LogFormat, destination: LogDestin let filter = EnvFilter::new(&level) .add_directive("h2=off".parse().unwrap()) .add_directive("tower::buffer=off".parse().unwrap()) - .add_directive("hyper_util=off".parse().unwrap()); + .add_directive("hyper_util=off".parse().unwrap()) + .add_directive("opentelemetry=off".parse().unwrap()); let subscriber = tracing_subscriber::registry() .with(create_fmt_layer(&level, format, destination))