1use std::fmt::Write as _;
20
21use serde::{Deserialize, Serialize};
22
23use super::{LineKind, LineRead, StoredLine, StyledLine, classify, plain, prefix, time_of};
24use crate::api::{Job, RecordNote, RecordState, Step, Tone};
25
26pub(crate) const DEPTH_MAX: usize = 8;
28
29pub(crate) const GROUP_MAX: u64 = 1000;
31
32pub(crate) const MARK_MAX: u64 = 1000;
34
35const SECTION_MAX: u64 = 200;
37
38const TITLE_MAX: usize = 200;
40
41pub(crate) const TITLE_SOURCE_MAX: usize = 4 * TITLE_MAX;
43
44const TIME_PREFIX: u64 = 64;
46
47const EXIT_PREFIX: u64 = 256;
49
50const EXCERPT_LINE_BYTES: u64 = 4 << 10;
52
53const EXIT_SCAN: u64 = 200;
55
56const EXCERPT: u64 = 10;
58
59const SECTIONS: [&str; 4] = [
62 "Post job cleanup.",
63 "Cleaning up orphan processes",
64 "A job started hook has been configured by the self-hosted runner administrator",
65 "A job completed hook has been configured by the self-hosted runner administrator",
66];
67
68const HEADER: &str = "Run ";
70
71const HEADERLESS: [&str; 4] = [
74 "Initialize containers",
75 "Stop containers",
76 "Wait for all background steps",
77 "Create custom image",
78];
79
80const HEADERLESS_GROUPS: [&str; 2] = ["Pull down action image", "Build container for action use"];
84
85const EXIT: &str = "Process completed with exit code ";
87
88#[derive(Debug, Clone, Default, PartialEq, Eq)]
90pub struct SavedOutline {
91 pub from: u64,
93 pub errors: u64,
95 pub warnings: u64,
97 pub groups: u64,
99 pub marks: u64,
101 pub sections: u64,
103 pub dropped: u64,
105 pub hidden: u64,
107 pub open: Vec<u64>,
109}
110
111#[derive(Debug, Clone, PartialEq, Eq)]
113pub enum OutlineChange {
114 Opened {
116 start: u64,
118 depth: u32,
120 title: String,
122 },
123 Closed {
125 start: u64,
127 end: u64,
129 },
130 Marked(LogMark),
132 Section {
134 line: u64,
136 },
137}
138
139#[derive(Debug)]
142pub struct Outliner {
143 saved: SavedOutline,
144}
145
146impl Outliner {
147 pub fn new(from: u64) -> Outliner {
149 Outliner {
150 saved: SavedOutline {
151 from,
152 ..SavedOutline::default()
153 },
154 }
155 }
156
157 pub fn resume(saved: SavedOutline) -> Outliner {
159 Outliner { saved }
160 }
161
162 pub fn saved(&self) -> &SavedOutline {
164 &self.saved
165 }
166
167 pub fn line(&mut self, line: u64, text: &str) -> Option<OutlineChange> {
169 let saved = &mut self.saved;
170 let (kind, rest) = classify(text);
171 match kind {
172 LineKind::Group => {
173 if saved.hidden > 0 || saved.open.len() >= DEPTH_MAX || saved.groups >= GROUP_MAX {
174 saved.hidden += 1;
175 saved.dropped += 1;
176 return None;
177 }
178 let depth = u32::try_from(saved.open.len()).unwrap_or(u32::MAX);
179 saved.open.push(line);
180 saved.groups += 1;
181 Some(OutlineChange::Opened {
182 start: line,
183 depth,
184 title: title(rest),
185 })
186 }
187 LineKind::EndGroup => {
188 if saved.hidden > 0 {
189 saved.hidden -= 1;
190 return None;
191 }
192 let start = saved.open.pop()?;
194 Some(OutlineChange::Closed { start, end: line })
195 }
196 LineKind::Error | LineKind::Warning => {
197 let kind = if kind == LineKind::Error {
198 saved.errors += 1;
199 MarkKind::Error
200 } else {
201 saved.warnings += 1;
202 MarkKind::Warning
203 };
204 (saved.marks < MARK_MAX).then(|| {
205 saved.marks += 1;
206 OutlineChange::Marked(LogMark { line, kind })
207 })
208 }
209 LineKind::Output if SECTIONS.contains(&rest) && saved.sections < SECTION_MAX => {
210 saved.sections += 1;
211 Some(OutlineChange::Section { line })
212 }
213 _ => None,
214 }
215 }
216}
217
218pub(crate) fn title(text: &str) -> String {
221 let title = plain(prefix(text, TITLE_SOURCE_MAX));
222 prefix(&title, TITLE_MAX).to_owned()
223}
224
225#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
227pub struct LineRange {
228 pub from: u64,
230 pub to: u64,
232}
233
234impl LineRange {
235 pub fn is_empty(&self) -> bool {
237 self.to <= self.from
238 }
239}
240
241#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
243pub struct LogGroup {
244 pub start: u64,
246 #[serde(default, skip_serializing_if = "Option::is_none")]
248 pub end: Option<u64>,
249 pub depth: u32,
251 pub title: String,
253}
254
255#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
257#[serde(rename_all = "kebab-case")]
258pub enum MarkKind {
259 Error,
261 Warning,
263 #[serde(other)]
265 Unknown,
266}
267
268#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
270pub struct LogMark {
271 pub line: u64,
273 pub kind: MarkKind,
275}
276
277#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
279#[serde(tag = "kind", rename_all = "kebab-case")]
280pub enum StepLog {
281 Lines(LineRange),
283 Empty,
285 Unattributed,
287 #[serde(other)]
289 Unknown,
290}
291
292#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
294pub struct StepLines {
295 pub number: u32,
297 pub lines: StepLog,
299}
300
301#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
303#[serde(rename_all = "kebab-case")]
304pub enum LogEvidence {
305 Complete,
307 Running,
309 Partial,
311 Truncated,
313 Expired,
315 Missing,
317 NotOutlined,
319 #[serde(other)]
321 Unknown,
322}
323
324impl LogEvidence {
325 pub fn words(self) -> Option<&'static str> {
327 match self {
328 LogEvidence::Complete => None,
329 LogEvidence::Running => Some("still running"),
330 LogEvidence::Partial => Some("outlined from a later line"),
331 LogEvidence::Truncated => Some("cut at history.log_max"),
332 LogEvidence::Expired => Some("deleted after history.logs"),
333 LogEvidence::Missing => Some("no log was captured"),
334 LogEvidence::NotOutlined => Some("kept without an outline"),
335 LogEvidence::Unknown => Some("read by a newer runnerd"),
336 }
337 }
338
339 pub fn tone(self) -> Tone {
341 match self {
342 LogEvidence::Truncated => Tone::Warn,
343 LogEvidence::Complete => Tone::Neutral,
344 _ => Tone::Quiet,
345 }
346 }
347
348 pub fn grows(self) -> bool {
350 self == LogEvidence::Running
351 }
352}
353
354#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
356pub struct FailureSummary {
357 #[serde(default, skip_serializing_if = "Option::is_none")]
359 pub step: Option<u32>,
360 #[serde(default, skip_serializing_if = "Option::is_none")]
362 pub exit_code: Option<i64>,
363 #[serde(default, skip_serializing_if = "Option::is_none")]
365 pub excerpt: Option<Vec<StyledLine>>,
366 #[serde(default, skip_serializing_if = "Option::is_none")]
368 pub shell: Option<String>,
369}
370
371impl FailureSummary {
372 pub fn headline(&self, steps: &[Step]) -> String {
374 let Some(number) = self.step else {
375 return "No step reports the failure".to_owned();
376 };
377 let mut text = match steps.iter().find(|step| step.number == number) {
378 Some(step) => format!("Step {number}, {}, failed", title(&step.name)),
379 None => format!("Step {number} failed"),
380 };
381 if let Some(code) = self.exit_code {
382 write!(text, " with exit code {code}").ok();
383 }
384 text
385 }
386}
387
388#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
390pub struct LogOutline {
391 pub job: u64,
393 pub evidence: LogEvidence,
395 pub lines: u64,
397 pub from: u64,
399 pub groups: Vec<LogGroup>,
401 pub steps: Vec<StepLines>,
403 pub unattributed: Vec<LineRange>,
405 pub errors: u64,
407 pub warnings: u64,
409 pub marks: Vec<LogMark>,
411 pub capped: bool,
413 #[serde(default, skip_serializing_if = "Option::is_none")]
415 pub failure: Option<FailureSummary>,
416}
417
418#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
420pub struct StoredLog {
421 pub lines: u64,
423 pub truncated: bool,
425 pub kept: bool,
427}
428
429#[derive(Debug, Clone, Default, PartialEq, Eq)]
432pub struct OutlineParts {
433 pub saved: Option<SavedOutline>,
435 pub groups: Vec<LogGroup>,
437 pub marks: Vec<LogMark>,
439 pub sections: Vec<u64>,
441}
442
443#[derive(Debug)]
445struct Segment {
446 range: LineRange,
447 first: Option<u64>,
449 last: Option<u64>,
450}
451
452impl LogOutline {
453 pub fn count_words(lines: usize) -> String {
455 if lines == 1 {
456 "1 line".to_owned()
457 } else {
458 format!("{lines} lines")
459 }
460 }
461
462 pub fn tail_words(first: u64, shown: usize) -> Option<String> {
465 (first > 0)
466 .then(|| format!("the last {shown} lines; the full log has the {first} before them"))
467 }
468
469 pub fn assemble(
473 job: &Job,
474 stored: StoredLog,
475 parts: OutlineParts,
476 read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
477 ) -> LogOutline {
478 let evidence = evidence(job, stored, parts.saved.as_ref());
479 let outlined = stored.kept && parts.saved.is_some();
480 let saved = parts.saved.unwrap_or_default();
481 let from = if outlined { saved.from } else { stored.lines };
482 let segments = if outlined {
483 segments(from, stored.lines, &parts.groups, &parts.sections, read)
484 } else {
485 Vec::new()
486 };
487 let ends = Ends {
488 leading: from > 0,
489 trailing: stored.truncated || !job.summary.state.is_final(),
490 };
491 let ranges = block_starts(from, stored.lines, &parts.groups, &parts.sections, &saved)
492 .and_then(|starts| by_blocks(&job.steps, &segments, &starts, ends))
493 .unwrap_or_else(|| attribute(&job.steps, &segments));
494 let steps: Vec<StepLines> = job
495 .steps
496 .iter()
497 .zip(&ranges)
498 .map(|(step, range)| StepLines {
499 number: step.number,
500 lines: match range {
501 Some(range) => StepLog::Lines(*range),
502 None if step.started_at.is_none()
503 || step.conclusion.as_deref() == Some("skipped") =>
504 {
505 StepLog::Empty
506 }
507 None => StepLog::Unattributed,
508 },
509 })
510 .collect();
511 let readable = !matches!(evidence, LogEvidence::Expired | LogEvidence::Missing);
512 let unattributed = if readable {
513 gaps(stored.lines, ranges.iter().flatten())
514 } else {
515 Vec::new()
516 };
517 let failure = job.summary.is_failure().then(|| failure(job, &steps, read));
518 LogOutline {
519 job: job.summary.id,
520 evidence,
521 lines: stored.lines,
522 from,
523 capped: saved.dropped > 0 || saved.marks < saved.errors + saved.warnings,
524 errors: saved.errors,
525 warnings: saved.warnings,
526 groups: parts.groups,
527 marks: parts.marks,
528 steps,
529 unattributed,
530 failure,
531 }
532 }
533
534 pub fn of(job: &Job, lines: &[String]) -> LogOutline {
536 let mut outliner = Outliner::new(0);
537 let mut parts = OutlineParts::default();
538 for (number, text) in (0..).zip(lines) {
539 match outliner.line(number, text) {
540 Some(OutlineChange::Opened {
541 start,
542 depth,
543 title,
544 }) => {
545 parts.groups.push(LogGroup {
546 start,
547 end: None,
548 depth,
549 title,
550 });
551 }
552 Some(OutlineChange::Closed { start, end }) => {
553 if let Some(group) = parts.groups.iter_mut().find(|group| group.start == start)
554 {
555 group.end = Some(end);
556 }
557 }
558 Some(OutlineChange::Marked(mark)) => parts.marks.push(mark),
559 Some(OutlineChange::Section { line }) => parts.sections.push(line),
560 None => {}
561 }
562 }
563 parts.saved = (!lines.is_empty()).then(|| outliner.saved().clone());
564 let stored = StoredLog {
565 lines: lines.len() as u64,
566 truncated: job.summary.log.truncated,
567 kept: true,
568 };
569 LogOutline::assemble(job, stored, parts, &mut |read| read.of(lines))
570 }
571
572 pub fn step_lines(&self, number: u32) -> Option<LineRange> {
574 self.steps
575 .iter()
576 .find(|step| step.number == number)
577 .and_then(|step| match step.lines {
578 StepLog::Lines(range) => Some(range),
579 _ => None,
580 })
581 }
582}
583
584fn evidence(job: &Job, stored: StoredLog, saved: Option<&SavedOutline>) -> LogEvidence {
585 let fin = job.summary.state.is_final();
586 if stored.lines > 0 && !stored.kept {
587 return LogEvidence::Expired;
588 }
589 if stored.truncated {
591 return LogEvidence::Truncated;
592 }
593 if stored.lines == 0 {
594 return if fin {
595 LogEvidence::Missing
596 } else {
597 LogEvidence::Running
598 };
599 }
600 let Some(saved) = saved else {
601 return LogEvidence::NotOutlined;
602 };
603 if saved.from > 0 {
604 LogEvidence::Partial
605 } else if !fin {
606 LogEvidence::Running
607 } else {
608 LogEvidence::Complete
609 }
610}
611
612fn read_range(
614 read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
615 range: LineRange,
616 prefix: u64,
617) -> Vec<StoredLine> {
618 let mut lines = read(LineRead {
619 from: range.from,
620 limit: range.to.saturating_sub(range.from),
621 prefix,
622 bytes: u64::MAX,
623 });
624 lines.retain(|line| line.line < range.to);
625 lines
626}
627
628fn segments(
630 from: u64,
631 lines: u64,
632 groups: &[LogGroup],
633 sections: &[u64],
634 read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
635) -> Vec<Segment> {
636 let mut starts: Vec<u64> = std::iter::once(from)
637 .chain(groups.iter().map(|group| group.start))
638 .chain(sections.iter().copied())
639 .filter(|start| (from..lines).contains(start))
640 .collect();
641 starts.sort_unstable();
642 starts.dedup();
643 let mut time = |line: u64| {
644 read_range(
645 read,
646 LineRange {
647 from: line,
648 to: line + 1,
649 },
650 TIME_PREFIX,
651 )
652 .first()
653 .and_then(|line| time_of(&line.text))
654 };
655 starts
656 .iter()
657 .enumerate()
658 .map(|(index, &start)| {
659 let end = starts.get(index + 1).copied().unwrap_or(lines);
660 Segment {
661 range: LineRange {
662 from: start,
663 to: end,
664 },
665 first: time(start),
666 last: time(end - 1),
667 }
668 })
669 .collect()
670}
671
672fn holds(step: &Step, at: u64) -> bool {
674 step.started_at
675 .is_some_and(|started| at >= started && step.completed_at.is_none_or(|end| at <= end))
676}
677
678fn attribute(steps: &[Step], segments: &[Segment]) -> Vec<Option<LineRange>> {
680 let mut ranges: Vec<Option<LineRange>> = vec![None; steps.len()];
681 let mut earliest = 0;
682 for segment in segments {
683 let times: Vec<u64> = [segment.first, segment.last]
684 .into_iter()
685 .flatten()
686 .collect();
687 if times.is_empty() {
688 continue;
689 }
690 let mut candidates = (earliest..steps.len())
691 .filter(|&index| times.iter().all(|&at| holds(&steps[index], at)));
692 let chosen = match (candidates.next(), candidates.next()) {
693 (Some(only), None) => Some(only),
694 _ => None,
695 };
696 if let Some(index) = chosen {
697 earliest = index;
698 let range = ranges[index].get_or_insert(segment.range);
699 range.to = segment.range.to;
700 }
701 }
702 ranges
703}
704
705#[derive(Debug, Clone, Copy)]
708struct Ends {
709 leading: bool,
710 trailing: bool,
711}
712
713fn block_starts(
717 from: u64,
718 lines: u64,
719 groups: &[LogGroup],
720 sections: &[u64],
721 saved: &SavedOutline,
722) -> Option<Vec<u64>> {
723 let headerless = groups.iter().any(|group| {
724 group.depth == 0
725 && HEADERLESS_GROUPS
726 .iter()
727 .any(|title| group.title.starts_with(title))
728 });
729 if saved.dropped > 0 || saved.sections >= SECTION_MAX || headerless {
730 return None;
731 }
732 let headers = groups
733 .iter()
734 .filter(|group| group.depth == 0 && group.title.starts_with(HEADER))
735 .map(|group| group.start)
736 .filter(|&start| start == 0 || !sections.contains(&(start - 1)));
737 let mut starts: Vec<u64> = std::iter::once(from)
738 .chain(sections.iter().copied())
739 .chain(headers)
740 .filter(|start| (from..lines).contains(start))
741 .collect();
742 starts.sort_unstable();
743 starts.dedup();
744 Some(starts)
745}
746
747#[derive(Debug)]
749struct Block {
750 range: LineRange,
752 times: Option<(u64, u64)>,
754}
755
756fn by_blocks(
759 steps: &[Step],
760 segments: &[Segment],
761 starts: &[u64],
762 ends: Ends,
763) -> Option<Vec<Option<LineRange>>> {
764 if steps
765 .iter()
766 .any(|step| HEADERLESS.contains(&step.name.as_str()))
767 {
768 return None;
769 }
770 let mut blocks: Vec<Block> = Vec::new();
771 for segment in segments {
772 let opens = starts.binary_search(&segment.range.from).is_ok();
773 if opens || blocks.is_empty() {
774 blocks.push(Block {
775 range: LineRange {
776 from: segment.range.from,
777 to: segment.range.from,
778 },
779 times: None,
780 });
781 }
782 let block = blocks.last_mut()?;
783 for at in [segment.first, segment.last].into_iter().flatten() {
784 let (low, high) = block.times.get_or_insert((at, at));
785 *low = (*low).min(at);
786 *high = (*high).max(at);
787 block.range.to = segment.range.to;
788 }
789 }
790 let ran: Vec<usize> = (0..steps.len())
792 .filter(|&index| {
793 steps[index].started_at.is_some()
794 && steps[index].conclusion.as_deref() != Some("skipped")
795 })
796 .collect();
797 let owners = Orders::new(&blocks, steps, &ran, ends)?.owners();
798 let mut ranges: Vec<Option<LineRange>> = vec![None; steps.len()];
799 for (block, owner) in blocks.iter().zip(owners) {
800 if let (Some(index), Some(_), false) = (owner, block.times, block.range.is_empty()) {
801 let range = ranges[index].get_or_insert(block.range);
802 range.to = block.range.to;
803 }
804 }
805 Some(ranges)
806}
807
808struct Orders<'log> {
812 blocks: &'log [Block],
813 steps: &'log [Step],
814 ran: &'log [usize],
815 ends: Ends,
816 fresh: Vec<bool>,
818 open: Vec<bool>,
820}
821
822impl<'log> Orders<'log> {
823 fn new(
825 blocks: &'log [Block],
826 steps: &'log [Step],
827 ran: &'log [usize],
828 ends: Ends,
829 ) -> Option<Orders<'log>> {
830 let cells = (blocks.len() + 1) * (ran.len() + 1);
831 let mut orders = Orders {
832 blocks,
833 steps,
834 ran,
835 ends,
836 fresh: vec![false; cells],
837 open: vec![false; cells],
838 };
839 orders.fresh[0] = true;
840 for i in 0..=blocks.len() {
841 for k in 0..ran.len() {
842 let at = orders.cell(i, k);
843 if orders.fresh[at] && orders.may_skip(i, k) {
844 let next = orders.cell(i, k + 1);
845 orders.fresh[next] = true;
846 }
847 if orders.open[at] {
848 let next = orders.cell(i, k + 1);
849 orders.fresh[next] = true;
850 }
851 if i < blocks.len() && (orders.fresh[at] || orders.open[at]) && orders.fits(i, k) {
852 let next = orders.cell(i + 1, k);
853 orders.open[next] = true;
854 }
855 }
856 }
857 let done = orders.cell(blocks.len(), ran.len());
858 orders.fresh[done].then_some(orders)
859 }
860
861 fn cell(&self, i: usize, k: usize) -> usize {
862 i * (self.ran.len() + 1) + k
863 }
864
865 fn may_skip(&self, i: usize, k: usize) -> bool {
867 let ended = matches!(
868 self.steps[self.ran[k]].conclusion.as_deref(),
869 Some("success" | "failure")
870 );
871 !ended || (i == 0 && self.ends.leading) || (i == self.blocks.len() && self.ends.trailing)
872 }
873
874 fn fits(&self, i: usize, k: usize) -> bool {
876 let step = &self.steps[self.ran[k]];
877 self.blocks[i]
878 .times
879 .is_none_or(|(low, high)| holds(step, low) && holds(step, high))
880 }
881
882 fn owners(&self) -> Vec<Option<usize>> {
884 let (blocks, ran) = (self.blocks.len(), self.ran.len());
885 let mut fresh = vec![false; self.fresh.len()];
887 let mut open = vec![false; self.open.len()];
888 let done = self.cell(blocks, ran);
889 fresh[done] = true;
890 for i in (0..=blocks).rev() {
891 for k in (0..ran).rev() {
892 let at = self.cell(i, k);
893 let next_step = fresh[self.cell(i, k + 1)];
894 let takes = i < blocks && self.fits(i, k) && open[self.cell(i + 1, k)];
895 fresh[at] = (self.may_skip(i, k) && next_step) || takes;
896 open[at] = next_step || takes;
897 }
898 }
899 (0..blocks)
900 .map(|i| {
901 let mut owners = (0..ran).filter(|&k| {
902 let at = self.cell(i, k);
903 (self.fresh[at] || self.open[at])
904 && self.fits(i, k)
905 && open[self.cell(i + 1, k)]
906 });
907 match (owners.next(), owners.next()) {
908 (Some(only), None) => Some(self.ran[only]),
909 _ => None,
910 }
911 })
912 .collect()
913 }
914}
915
916fn gaps<'range>(lines: u64, ranges: impl Iterator<Item = &'range LineRange>) -> Vec<LineRange> {
918 let mut ranges: Vec<LineRange> = ranges.copied().collect();
919 ranges.sort_unstable_by_key(|range| range.from);
920 let mut gaps = Vec::new();
921 let mut at = 0;
922 for range in ranges {
923 if range.from > at {
924 gaps.push(LineRange {
925 from: at,
926 to: range.from,
927 });
928 }
929 at = at.max(range.to);
930 }
931 if at < lines {
932 gaps.push(LineRange {
933 from: at,
934 to: lines,
935 });
936 }
937 gaps
938}
939
940fn failure(
942 job: &Job,
943 steps: &[StepLines],
944 read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
945) -> FailureSummary {
946 let step = job
947 .steps
948 .iter()
949 .find(|step| step.conclusion.as_deref() == Some("failure"))
950 .map(|step| step.number);
951 let range = step.and_then(|number| {
952 steps
953 .iter()
954 .find(|step| step.number == number)
955 .and_then(|step| match step.lines {
956 StepLog::Lines(range) => Some(range),
957 _ => None,
958 })
959 });
960 let last = |count: u64, range: LineRange| LineRange {
961 from: range.to.saturating_sub(count).max(range.from),
962 to: range.to,
963 };
964 let exit_code = range.and_then(|range| {
965 read_range(read, last(EXIT_SCAN, range), EXIT_PREFIX)
966 .iter()
967 .rev()
968 .map(StoredLine::styled)
969 .find_map(|line| {
970 (line.kind == LineKind::Error && line.omitted == 0)
972 .then(|| line.text())
973 .and_then(|text| {
974 text.strip_prefix(EXIT)?
975 .strip_suffix('.')?
976 .parse::<i64>()
977 .ok()
978 })
979 })
980 });
981 let excerpt = range.map(|range| {
982 read_range(read, last(EXCERPT, range), EXCERPT_LINE_BYTES)
983 .iter()
984 .map(StoredLine::styled)
985 .collect()
986 });
987 let shell = job
988 .record
989 .as_ref()
990 .filter(|record| matches!(record.state(), RecordState::Kept { .. }))
991 .map(|_| RecordNote::shell_command(job.summary.id));
992 FailureSummary {
993 step,
994 exit_code,
995 excerpt,
996 shell,
997 }
998}