git.delta.rocks / jrsonnet / refs/commits / 3bff084b3bc8

--- a/cmds/fleet/src/cmds/build_systems.rs
+++ b/cmds/fleet/src/cmds/build_systems.rs
@@ -118,7 +118,7 @@
 					{
 						Ok(path) => path,
 						Err(e) => {
-							error!("failed to build host system closure: {:#}", e);
+							error!("failed to build host system closure: {:?}", e);
 							return;
 						}
 					};

--- a/crates/nix-eval/build.rs
+++ b/crates/nix-eval/build.rs
@@ -16,6 +16,7 @@
 	// Link nix C++ libraries for cxx
 	for lib in &[
 		"nix-util",
+		"nix-util-c",
 		"nix-store",
 		"nix-expr",
 		"nix-flake",
@@ -34,12 +35,12 @@
 
 	cxx_build::bridge("src/logging.rs")
 		.file("src/logging.cc")
-		.std("c++20")
+		.std("c++23")
 		.shared_flag(true)
 		.compile("nix-eval-logging");
 	cxx_build::bridge("src/lib.rs")
 		.file("src/lib.cc")
-		.std("c++20")
+		.std("c++23")
 		.shared_flag(true)
 		.compile("nix-eval");
 

13pub use anyhow::Result;13pub use anyhow::Result;
14use tracing::instrument;14use tracing::instrument;
1515
16use self::logging::nix_logging_cxx;16use self::logging::{ErrorInfoBuilder, nix_logging_cxx};
17use self::nix_cxx::set_fetcher_setting;17use self::nix_cxx::set_fetcher_setting;
18use self::nix_raw::{18use self::nix_raw::{
19	BindingsBuilder as c_bindings_builder, EvalState as c_eval_state, GC_SUCCESS,19	BindingsBuilder as c_bindings_builder, EvalState as c_eval_state, GC_SUCCESS,
179		let code = unsafe { err_code(self.0) };179		let code = unsafe { err_code(self.0) };
180		NixErrorKind::from_int(code)180		NixErrorKind::from_int(code)
181	}181	}
182	fn error<'t>(&self) -> Option<Cow<'t, str>> {182	fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {
183		if let NixErrorKind::Generic = self.error_kind()? {183		if let NixErrorKind::Generic = self.error_kind()? {
184			let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };
184			let mut err_out = String::new();185			let mut err_out = String::new();
185			unsafe {186			unsafe {
186				err_info_msg(187				err_info_msg(
190					(&raw mut err_out).cast(),191					(&raw mut err_out).cast(),
191				)192				)
192			};193			};
193			return Some(Cow::Owned(err_out));194			return Some((Cow::Owned(err_out), Some(ei)));
194		};195		};
195196
196		// TODO: Can throw error (resulting in panic) if unable to retrieve error. Should be able to resolve by passing context as a first argument,197		// TODO: Can throw error (resulting in panic) if unable to retrieve error. Should be able to resolve by passing context as a first argument,
197		// but it looks ugly198		// but it looks ugly
198		let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };199		let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };
199		Some(unsafe { CStr::from_ptr(str) }.to_string_lossy())200		Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))
200	}201	}
201	fn clean_err(&mut self) {202	fn clean_err(&mut self) {
202		unsafe {203		unsafe {
205	}206	}
206207
207	fn bail_if_error(&self) -> Result<()> {208	fn bail_if_error(&self) -> Result<()> {
208		if let Some(err) = self.error() {209		if let Some((err, stack)) = self.error() {
209			bail!("{err}");210			let mut e = Err(anyhow!("{err}"));
211			if let Some(stack) = stack {
212				for ele in stack.stack_frames {
213					e = e.with_context(|| {
214						if ele.pos.is_empty() {
215							ele.msg
216						} else {
217							format!("{} at {}", ele.msg, ele.pos)
218						}
219					})
220				}
221			}
222			return e.context("<nix frames>");
210		};223		};
211		Ok(())224		Ok(())
212	}225	}

--- a/crates/nix-eval/src/logging.cc
+++ b/crates/nix-eval/src/logging.cc
@@ -1,9 +1,36 @@
-#include "nix-eval/src/logging.rs"
 #include "logging.hh"
 #include <nix/util/logging.hh>
+#include <nix/util/position.hh>
 
 using namespace nix;
 
+rust::Box<ErrorInfoBuilder> copy_error_info(const ErrorInfo &ei) {
+  auto s = ei.msg.str();
+  rust::Slice<const unsigned char> str(
+      reinterpret_cast<const unsigned char *>(s.data()), s.size());
+  auto b = new_error_info(ei.level, str);
+  if (!ei.traces.empty()) {
+    for (auto iter = ei.traces.rbegin(); iter != ei.traces.rend(); ++iter) {
+      auto msg = iter->hint.str();
+
+      rust::Slice<const unsigned char> msgv(
+          reinterpret_cast<const unsigned char *>(msg.data()), msg.size());
+
+      std::ostringstream oss;
+      if (iter->pos) {
+        iter->pos->print(oss, true);
+      }
+      std::string pos = oss.str();
+
+      rust::Slice<const unsigned char> posv(
+          reinterpret_cast<const unsigned char *>(pos.data()), pos.size());
+
+      b->push_stack_frame(msgv, posv);
+    }
+  }
+  return b;
+}
+
 struct TracingLogger : Logger {
   TracingLogger() {}
 
@@ -14,10 +41,8 @@
     emit_log(lvl, str);
   }
   void logEI(const ErrorInfo &ei) override {
-    auto s = ei.msg.str();
-    rust::Slice<const unsigned char> str(
-        reinterpret_cast<const unsigned char *>(s.data()), s.size());
-    emit_log(ei.level, str);
+    auto b = copy_error_info(ei);
+    b->emit_error_info();
   }
 
   void startActivity(ActivityId act, Verbosity lvl, ActivityType type,
@@ -74,4 +99,8 @@
   logger = std::make_unique<TracingLogger>();
   // verbosity = lvlVomit;
 }
+rust::Box<ErrorInfoBuilder>
+extract_error_info(const nix_c_context *read_context) {
+  return copy_error_info(read_context->info.value());
+}
 }

--- a/crates/nix-eval/src/logging.hh
+++ b/crates/nix-eval/src/logging.hh
@@ -1,5 +1,12 @@
 #pragma once
+#include "nix-eval/src/logging.rs"
+#include "rust/cxx.h"
+#include <nix_api_util.h>
+#include <nix_api_util_internal.h>
+
+struct ErrorInfoBuilder;
 
 extern "C" {
 void apply_tracing_logger();
+rust::Box<ErrorInfoBuilder> extract_error_info(const nix_c_context *ctx);
 }

--- a/crates/nix-eval/src/logging.rs
+++ b/crates/nix-eval/src/logging.rs
@@ -2,6 +2,7 @@
 use std::fmt::Arguments;
 use std::sync::{LazyLock, Mutex};
 
+use cxx::ExternType;
 use tracing::{
 	Level, Span, debug, debug_span, error, error_span, info, info_span, trace, trace_span, warn,
 	warn_span,
@@ -535,6 +536,45 @@
 	out.output
 }
 
+#[derive(Debug)]
+pub struct StackFrame {
+	pub msg: String,
+	pub pos: String,
+}
+
+#[derive(Debug)]
+pub struct ErrorInfoBuilder {
+	level: Level,
+	msg: String,
+	pub stack_frames: Vec<StackFrame>,
+}
+fn new_error_info(lvl: u32, v: &[u8]) -> Box<ErrorInfoBuilder> {
+	let verbosity = Verbosity::from_int(lvl);
+	let level: Level = verbosity.into();
+	let v = String::from_utf8_lossy(v);
+	Box::new(ErrorInfoBuilder {
+		level,
+		msg: v.to_string(),
+		stack_frames: Vec::new(),
+	})
+}
+impl ErrorInfoBuilder {
+	fn push_stack_frame(&mut self, v: &[u8], pos: &[u8]) {
+		let v = String::from_utf8_lossy(v);
+		let pos = String::from_utf8_lossy(pos);
+		self.stack_frames.push(StackFrame {
+			msg: v.to_string(),
+			pos: pos.to_string(),
+		});
+	}
+	fn emit_error_info(&mut self) {
+		error!("{}", self.msg);
+		for frame in &self.stack_frames {
+			error!("  {} at {}", frame.msg, frame.pos)
+		}
+	}
+}
+
 #[cxx::bridge]
 pub mod nix_logging_cxx {
 	extern "Rust" {
@@ -544,7 +584,14 @@
 		fn add_string_field(&mut self, v: &[u8]);
 		fn emit(&mut self, parent: u64, s: &str);
 		fn emit_result(&mut self, ty: u32);
-
+	}
+	extern "Rust" {
+		type ErrorInfoBuilder;
+		fn new_error_info(lvl: u32, v: &[u8]) -> Box<ErrorInfoBuilder>;
+		fn push_stack_frame(&mut self, v: &[u8], pos: &[u8]);
+		fn emit_error_info(&mut self);
+	}
+	extern "Rust" {
 		fn emit_warn(v: &str);
 		fn emit_stop(id: u64);
 		fn emit_log(lvl: u32, v: &[u8]);
@@ -552,6 +599,15 @@
 	unsafe extern "C++" {
 		include!("nix-eval/src/logging.hh");
 
+		type nix_c_context = crate::nix_raw::c_context;
+
 		fn apply_tracing_logger();
+		unsafe fn extract_error_info(ctx: *const nix_c_context) -> Box<ErrorInfoBuilder>;
 	}
 }
+
+unsafe impl ExternType for crate::nix_raw::c_context {
+	type Id = cxx::type_id!("nix_c_context");
+
+	type Kind = cxx::kind::Opaque;
+}