fix: otel resiliency

Cargo.toml

@@ -141,7 +141,7 @@ jsonc-parser = { version = "=0.26.2", features = ["serde"] }
 lazy-regex = "3"
 libc = "0.2.126"
 libz-sys = { version = "1.1.20", default-features = false }
-log = "0.4.20"
+log = { version = "0.4.20", features = ["kv"] }
 lsp-types = "=0.97.0" # used by tower-lsp and "proposed" feature is unstable in patch releases
 memmem = "0.1.1"
 monch = "=0.5.0"

cli/args/flags.rs

@@ -36,6 +36,7 @@ use deno_path_util::normalize_path;
 use deno_path_util::url_to_file_path;
 use deno_runtime::deno_permissions::PermissionsOptions;
 use deno_runtime::deno_permissions::SysDescriptor;
+use deno_runtime::ops::otel::OtelConfig;
 use log::debug;
 use log::Level;
 use serde::Deserialize;
@@ -968,6 +969,24 @@ impl Flags {
     args
   }
 
+  pub fn otel_config(&self) -> Option<OtelConfig> {
+    if self
+      .unstable_config
+      .features
+      .contains(&String::from("otel"))
+    {
+      Some(OtelConfig {
+        runtime_name: Cow::Borrowed("deno"),
+        runtime_version: Cow::Borrowed(crate::version::DENO_VERSION_INFO.deno),
+        deterministic: std::env::var("DENO_UNSTABLE_OTEL_DETERMINISTIC")
+          .is_ok(),
+        ..Default::default()
+      })
+    } else {
+      None
+    }
+  }
+
   /// Extract the paths the config file should be discovered from.
   ///
   /// Returns `None` if the config file should not be auto-discovered.

cli/args/mod.rs

@@ -823,10 +823,8 @@ impl CliOptions {
       };
       let msg =
         format!("DANGER: TLS certificate validation is disabled {}", domains);
-      #[allow(clippy::print_stderr)]
       {
-        // use eprintln instead of log::warn so this always gets shown
-        eprintln!("{}", colors::yellow(msg));
+        log::error!("{}", colors::yellow(msg));
       }
     }
 
@@ -1131,20 +1129,7 @@ impl CliOptions {
   }
 
   pub fn otel_config(&self) -> Option<OtelConfig> {
-    if self
-      .flags
-      .unstable_config
-      .features
-      .contains(&String::from("otel"))
-    {
-      Some(OtelConfig {
-        runtime_name: Cow::Borrowed("deno"),
-        runtime_version: Cow::Borrowed(crate::version::DENO_VERSION_INFO.deno),
-        ..Default::default()
-      })
-    } else {
-      None
-    }
+    self.flags.otel_config()
   }
 
   pub fn env_file_name(&self) -> Option<&String> {

cli/main.rs

@@ -350,18 +350,17 @@ fn setup_panic_hook() {
     eprintln!("Args: {:?}", env::args().collect::<Vec<_>>());
     eprintln!();
     orig_hook(panic_info);
-    std::process::exit(1);
+    deno_runtime::exit(1);
   }));
 }
 
-#[allow(clippy::print_stderr)]
 fn exit_with_message(message: &str, code: i32) -> ! {
-  eprintln!(
+  log::error!(
     "{}: {}",
     colors::red_bold("error"),
     message.trim_start_matches("error: ")
   );
-  std::process::exit(code);
+  deno_runtime::exit(code);
 }
 
 fn exit_for_error(error: AnyError) -> ! {
@@ -380,13 +379,12 @@ fn exit_for_error(error: AnyError) -> ! {
   exit_with_message(&error_string, error_code);
 }
 
-#[allow(clippy::print_stderr)]
 pub(crate) fn unstable_exit_cb(feature: &str, api_name: &str) {
-  eprintln!(
+  log::error!(
     "Unstable API '{api_name}'. The `--unstable-{}` flag must be provided.",
     feature
   );
-  std::process::exit(70);
+  deno_runtime::exit(70);
 }
 
 pub fn main() {
@@ -419,7 +417,7 @@ pub fn main() {
   drop(profiler);
 
   match result {
-    Ok(exit_code) => std::process::exit(exit_code),
+    Ok(exit_code) => deno_runtime::exit(exit_code),
     Err(err) => exit_for_error(err),
   }
 }
@@ -433,12 +431,21 @@ fn resolve_flags_and_init(
       if err.kind() == clap::error::ErrorKind::DisplayVersion =>
     {
       // Ignore results to avoid BrokenPipe errors.
+      util::logger::init(None);
       let _ = err.print();
-      std::process::exit(0);
+      deno_runtime::exit(0);
+    }
+    Err(err) => {
+      util::logger::init(None);
+      exit_for_error(AnyError::from(err))
     }
-    Err(err) => exit_for_error(AnyError::from(err)),
   };
 
+  if let Some(otel_config) = flags.otel_config() {
+    deno_runtime::ops::otel::init(otel_config)?;
+  }
+  util::logger::init(flags.log_level);
+
   // TODO(bartlomieju): remove in Deno v2.5 and hard error then.
   if flags.unstable_config.legacy_flag_enabled {
     log::warn!(
@@ -467,7 +474,6 @@ fn resolve_flags_and_init(
   deno_core::JsRuntime::init_platform(
     None, /* import assertions enabled */ false,
   );
-  util::logger::init(flags.log_level);
 
   Ok(flags)
 }

cli/mainrt.rs

@@ -40,23 +40,21 @@ use std::env::current_exe;
 
 use crate::args::Flags;
 
-#[allow(clippy::print_stderr)]
 pub(crate) fn unstable_exit_cb(feature: &str, api_name: &str) {
-  eprintln!(
+  log::error!(
     "Unstable API '{api_name}'. The `--unstable-{}` flag must be provided.",
     feature
   );
-  std::process::exit(70);
+  deno_runtime::exit(70);
 }
 
-#[allow(clippy::print_stderr)]
 fn exit_with_message(message: &str, code: i32) -> ! {
-  eprintln!(
+  log::error!(
     "{}: {}",
     colors::red_bold("error"),
     message.trim_start_matches("error: ")
   );
-  std::process::exit(code);
+  deno_runtime::exit(code);
 }
 
 fn unwrap_or_exit<T>(result: Result<T, AnyError>) -> T {
@@ -89,13 +87,19 @@ fn main() {
   let future = async move {
     match standalone {
       Ok(Some(data)) => {
+        if let Some(otel_config) = data.metadata.otel_config.clone() {
+          deno_runtime::ops::otel::init(otel_config)?;
+        }
         util::logger::init(data.metadata.log_level);
         load_env_vars(&data.metadata.env_vars_from_env_file);
         let exit_code = standalone::run(data).await?;
-        std::process::exit(exit_code);
+        deno_runtime::exit(exit_code);
       }
       Ok(None) => Ok(()),
-      Err(err) => Err(err),
+      Err(err) => {
+        util::logger::init(None);
+        Err(err)
+      }
     }
   };
 

cli/standalone/binary.rs

@@ -517,7 +517,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       Some(bytes) => bytes,
       None => {
         log::info!("Download could not be found, aborting");
-        std::process::exit(1)
+        deno_runtime::exit(1);
       }
     };
 

cli/util/file_watcher.rs

@@ -73,7 +73,6 @@ impl DebouncedReceiver {
   }
 }
 
-#[allow(clippy::print_stderr)]
 async fn error_handler<F>(watch_future: F) -> bool
 where
   F: Future<Output = Result<(), AnyError>>,
@@ -84,7 +83,7 @@ where
       Some(e) => format_js_error(e),
       None => format!("{err:?}"),
     };
-    eprintln!(
+    log::error!(
       "{}: {}",
       colors::red_bold("error"),
       error_string.trim_start_matches("error: ")

cli/util/logger.rs

@@ -29,6 +29,7 @@ impl log::Log for CliLogger {
       // thread's state
       DrawThread::hide();
       self.0.log(record);
+      deno_runtime::ops::otel::handle_log(record);
       DrawThread::show();
     }
   }

cli/util/v8.rs

@@ -46,15 +46,14 @@ pub fn init_v8_flags(
     .skip(1)
     .collect::<Vec<_>>();
 
-  #[allow(clippy::print_stderr)]
   if !unrecognized_v8_flags.is_empty() {
     for f in unrecognized_v8_flags {
-      eprintln!("error: V8 did not recognize flag '{f}'");
+      log::error!("error: V8 did not recognize flag '{f}'");
     }
-    eprintln!("\nFor a list of V8 flags, use '--v8-flags=--help'");
-    std::process::exit(1);
+    log::error!("\nFor a list of V8 flags, use '--v8-flags=--help'");
+    deno_runtime::exit(1);
   }
   if v8_flags_includes_help {
-    std::process::exit(0);
+    deno_runtime::exit(0);
   }
 }

ext/napi/node_api.rs

@@ -140,7 +140,6 @@ fn napi_fatal_exception(env: &mut Env, err: napi_value) -> napi_status {
 }
 
 #[napi_sym]
-#[allow(clippy::print_stderr)]
 fn napi_fatal_error(
   location: *const c_char,
   location_len: usize,
@@ -173,9 +172,9 @@ fn napi_fatal_error(
   };
 
   if let Some(location) = location {
-    eprintln!("NODE API FATAL ERROR: {} {}", location, message);
+    log::error!("NODE API FATAL ERROR: {} {}", location, message);
   } else {
-    eprintln!("NODE API FATAL ERROR: {}", message);
+    log::error!("NODE API FATAL ERROR: {}", message);
   }
 
   std::process::abort();

ext/napi/uv.rs

@@ -5,10 +5,9 @@ use deno_core::parking_lot::Mutex;
 use std::mem::MaybeUninit;
 use std::ptr::addr_of_mut;
 
-#[allow(clippy::print_stderr)]
 fn assert_ok(res: c_int) -> c_int {
   if res != 0 {
-    eprintln!("bad result in uv polyfill: {res}");
+    log::error!("bad result in uv polyfill: {res}");
     // don't panic because that might unwind into
     // c/c++
     std::process::abort();

runtime/js/telemetry.js

@@ -22,11 +22,14 @@ const {
   ReflectApply,
   SymbolFor,
   Error,
+  NumberPrototypeToString,
+  StringPrototypePadStart,
 } = primordials;
 const { AsyncVariable, setAsyncContext } = core;
 
 const CURRENT = new AsyncVariable();
 let TRACING_ENABLED = false;
+let DETERMINISTIC = false;
 
 const SPAN_ID_BYTES = 8;
 const TRACE_ID_BYTES = 16;
@@ -45,7 +48,19 @@ const hexSliceLookupTable = (function () {
   return table;
 })();
 
+let counter = 1;
+
+const INVALID_SPAN_ID = "0000000000000000";
+const INVALID_TRACE_ID = "00000000000000000000000000000000";
+
 function generateId(bytes) {
+  if (DETERMINISTIC) {
+    return StringPrototypePadStart(
+      NumberPrototypeToString(counter++, 16),
+      bytes * 2,
+      "0",
+    );
+  }
   let out = "";
   for (let i = 0; i < bytes / 4; i += 1) {
     const r32 = (MathRandom() * 2 ** 32) >>> 0;
@@ -112,8 +127,6 @@ function submit(span) {
 
 const now = () => (performance.timeOrigin + performance.now()) / 1000;
 
-const INVALID_SPAN_ID = "0000000000000000";
-const INVALID_TRACE_ID = "00000000000000000000000000000000";
 const NO_ASYNC_CONTEXT = {};
 
 class Span {
@@ -362,9 +375,12 @@ const otelConsoleConfig = {
 
 export function bootstrap(config) {
   if (config.length === 0) return;
-  const { 0: consoleConfig } = config;
+  const { 0: consoleConfig, 1: deterministic } = config;
 
   TRACING_ENABLED = true;
+  if (deterministic === 1) {
+    DETERMINISTIC = true;
+  }
 
   switch (consoleConfig) {
     case otelConsoleConfig.capture:

runtime/lib.rs

@@ -140,6 +140,11 @@ pub static UNSTABLE_GRANULAR_FLAGS: &[UnstableGranularFlag] = &[
   },
 ];
 
+pub fn exit(code: i32) -> ! {
+  crate::ops::otel::flush();
+  std::process::exit(code);
+}
+
 #[cfg(test)]
 mod test {
   use super::*;

runtime/ops/os/mod.rs

@@ -186,10 +186,8 @@ fn op_get_exit_code(state: &mut OpState) -> i32 {
 
 #[op2(fast)]
 fn op_exit(state: &mut OpState) {
-  crate::ops::otel::otel_drop_state(state);
-
   let code = state.borrow::<ExitCode>().get();
-  std::process::exit(code)
+  crate::exit(code)
 }
 
 #[op2]