Report a bug: include the Messages log and other failing features (#7348) (#7349)

* claim: #7348

* Report a bug: include the Messages log and other failing features (#7348)

About half of the reports say "No command error was recorded" and often
can't be reproduced. The error was often in the Messages log, or on a
feature that was neither selected nor the latest. The technical details
now list every failing feature (id, name, kind, error; at most 10) and the
last 8 messages with level and age. Each entry is one quoted line of at
most 300 characters, with the home folder shown as ~.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
semmelrinde
2026-10-27 12:38:07 +00:00
committed by GitHub
parent 9d01dcb358
commit 9b84789da0
+148
View File
@@ -304,6 +304,84 @@ fn feature_context(feature: &solidcraft_engine::doc::Feature) -> String {
format!("Feature {}: {}\n{}", feature.id, debug(&feature.name, 160), block(&json_context(&feature.kind, 2000)))
}
/// Messages and feature errors listed in a report (#7348), each entry cut to `MAX_ENTRY_CHARS`.
const REPORT_MESSAGES: usize = 8;
const REPORT_FAILURES: usize = 10;
const MAX_ENTRY_CHARS: usize = 300;
/// The user's home folder as text, for [`report_text`]; a bare root is never replaced.
fn home_text() -> Option<String> {
let home = std::env::var_os(if cfg!(windows) { "USERPROFILE" } else { "HOME" })?;
let home = home.to_string_lossy().trim_end_matches(['/', '\\']).to_string();
(home.chars().count() > 1).then_some(home)
}
/// Untrusted text (messages, feature errors) as one quoted line: the home folder shown as `~`,
/// cut to `MAX_ENTRY_CHARS` characters.
fn report_text(text: &str, home: Option<&str>) -> String {
let mut text = limited(text, MAX_ENTRY_CHARS * 8);
if let Some(home) = home.filter(|h| h.chars().count() > 1) {
text = text.replace(home, "~");
}
if text.chars().count() > MAX_ENTRY_CHARS {
text = format!("{}…", text.chars().take(MAX_ENTRY_CHARS).collect::<String>());
}
format!("{text:?}")
}
/// How long ago `at` was, at `now` (both ms), in English like the rest of the report.
fn report_ago(now: f64, at: f64) -> String {
let s = ((now - at) / 1000.0).max(0.0);
let s = if s.is_finite() { s.floor() } else { 0.0 };
if s < 60.0 {
format!("{s:.0} s ago")
} else if s < 3600.0 {
format!("{:.0} min ago", (s / 60.0).floor())
} else {
format!("{:.0} h ago", (s / 3600.0).floor())
}
}
/// The last messages of the Messages log, oldest first.
fn messages_context(messages: &crate::messages::Messages, now: f64, home: Option<&str>) -> String {
let all = messages.iter();
let total = all.len();
if total == 0 {
return "\nMessages: none\n".into();
}
let shown = total.min(REPORT_MESSAGES);
let mut out = format!("\nMessages (last {shown} of {total}):\n");
for m in all.skip(total.saturating_sub(shown)) {
let level = if m.error { "error" } else { "info" };
let repeats = if m.count > 1 { format!(" (×{})", m.count) } else { String::new() };
out.push_str(&format!(" {} {level}: {}{repeats}\n", report_ago(now, m.at), report_text(&m.text, home)));
}
out
}
/// Every feature whose result has an error, in timeline order, not only the selected or latest one.
fn failures_context(app: &SolveApp, home: Option<&str>) -> String {
let mut failing = app.session.doc.features.iter().filter_map(|f| app.session.model.result(f.id)?.error.as_deref().map(|e| (f, e)));
let mut out = String::new();
let mut count = 0usize;
for (feature, error) in failing.by_ref().take(REPORT_FAILURES) {
count += 1;
out.push_str(&format!(
" Feature {} {} ({}): {}\n",
feature.id,
report_text(&feature.name, home),
feature.kind.type_name(),
report_text(error, home)
));
}
let more = failing.count();
match (count, more) {
(0, _) => "\nFailing features: none\n".into(),
(n, 0) => format!("\nFailing features ({n}):\n{out}"),
(n, more) => format!("\nFailing features (first {n} of {}):\n{out}", n + more),
}
}
/// Read-only context excludes whole documents, sketch geometry and imported file contents.
pub fn draft_for(app: &SolveApp, dialog: Option<&dialogs::Dialog>, error: Option<&str>) -> Draft {
let mut context = String::new();
@@ -341,6 +419,9 @@ pub fn draft_for(app: &SolveApp, dialog: Option<&dialogs::Dialog>, error: Option
context.push_str(&format!("Feature error: {}\n", debug(&e, 1000)));
}
}
let home = home_text();
context.push_str(&failures_context(app, home.as_deref()));
context.push_str(&messages_context(&app.messages, crate::now_ms(), home.as_deref()));
let actual = error.map(|e| debug(&e, 4000)).unwrap_or_else(|| "No command error was recorded.".into());
let image_state = if error.is_some() {
"A failed preview may display the last valid geometry; that geometry is not evidence that the failed operation succeeded."
@@ -877,6 +958,73 @@ mod tests {
assert_eq!(before, (app.session.doc.to_json(), app.session.revision, app.session.undo.len(), app.session.redo.len(), app.cam));
}
/// The sample with Fillet1 failing (the plate made narrower than its fillets).
fn failing_sample() -> SolveApp {
let mut s = Session::default();
s.run_script(&solidcraft_engine::sample::script()).unwrap();
s.execute("parameters.change", &json!({"name": "width", "expression": "5 mm"})).unwrap();
SolveApp::new(s, Default::default())
}
#[test]
fn issue_report_lists_the_last_messages_and_a_failing_feature_that_is_not_the_latest() {
let mut app = failing_sample();
let fillet = app.session.doc.features.iter().find(|f| f.name == "Fillet1").unwrap();
let error = app.session.model.result(fillet.id).and_then(|r| r.error.clone()).unwrap();
let latest = app.session.doc.features.iter().rev().find(|f| reportable(f)).unwrap();
assert_ne!(latest.id, fillet.id, "Fillet1 must not be the latest operation");
assert!(app.session.selection.is_empty());
let at = crate::now_ms() - 125_000.0;
for i in 0..12 {
app.messages.push(&format!("message number {i:02}"), i % 2 == 0, at);
}
app.messages.push("message number 11", false, at);
let draft = draft_for(&app, None, None);
let line = format!("Feature {} \"Fillet1\" (FilletFeature): {:?}", fillet.id, error);
assert!(draft.body.contains("Failing features (1):") && draft.body.contains(&line), "missing {line}: {}", draft.body);
assert!(draft.body.contains("Messages (last 8 of 12):"), "{}", draft.body);
for i in 0..4 {
assert!(!draft.body.contains(&format!("message number {i:02}")), "only the last 8 messages: {}", draft.body);
}
assert!(draft.body.contains("2 min ago error: \"message number 10\"\n"), "{}", draft.body);
assert!(draft.body.contains("2 min ago info: \"message number 11\" (×2)\n"), "{}", draft.body);
let latest = draft.body.find("Latest modeling operation").unwrap();
assert!(latest < draft.body.find("Failing features").unwrap() && latest < draft.body.find("Messages (").unwrap());
assert!(draft.body.find("Messages (").unwrap() < draft.body.find("## Environment").unwrap());
}
#[test]
fn issue_report_messages_and_feature_errors_hide_the_home_folder_and_stay_bounded() {
assert_eq!(report_text("Could not write /home/sample/Designs/part.step", Some("/home/sample")), "\"Could not write ~/Designs/part.step\"");
assert_eq!(report_text("/home/sample", Some("/")), "\"/home/sample\"", "a bare root is never replaced");
let mut app = app();
if let Some(home) = home_text() {
app.messages.push(&format!("Export failed: {home}/Designs/part.step is read-only"), true, crate::now_ms());
let draft = draft_for(&app, None, None);
assert!(draft.body.contains("error: \"Export failed: ~/Designs/part.step is read-only\""), "{}", draft.body);
assert!(!draft.body.contains(&home), "the home folder leaks: {}", draft.body);
}
for i in 0..12 {
app.run("solid.box", json!({"length":10,"width":10,"height":10,"body_name":format!("Box{i}")})).unwrap();
}
let hostile = "錯誤 ```\n## fake section 🚀".repeat(50_000);
for result in &mut app.session.model.results {
result.error = Some(hostile.clone());
}
app.messages.push(&hostile, true, f64::NAN);
let draft = draft_for(&app, None, None);
assert!(draft.body.len() <= MAX_BODY);
assert!(draft.body.contains("Failing features (first 10 of 12):"), "{}", draft.body);
assert!(!draft.body.contains("\n## fake section"), "untrusted text stays on one quoted line");
let section = draft.body.split("Failing features").nth(1).unwrap();
let section = section.split("\n## Environment").next().unwrap();
assert_eq!(section.lines().filter(|l| l.contains("錯誤")).count(), 11, "ten features and one message");
for line in section.lines() {
assert!(line.chars().count() < 2 * MAX_ENTRY_CHARS, "an entry is bounded: {} characters", line.chars().count());
}
assert!(section.contains("0 s ago error: \"錯誤"), "a broken time still reads: {section}");
}
#[test]
fn issue_report_hostile_context_and_url_are_bounded_without_new_query_parameters() {
let mut app = app();