1use crate::budget::{Budget, Exceeded, Kind, Limit};
4use crate::cancel::CancelToken;
5use crate::codes;
6use crate::diag::{Diagnostic, DiagnosticEvents, Diagnostics, EventCapture};
7
8#[derive(Debug)]
10pub struct Cx<'a> {
11 pub budget: &'a mut Budget,
13 pub diag: &'a mut Diagnostics,
15 pub cancel: &'a CancelToken,
17}
18
19#[derive(Clone, Copy, Debug, PartialEq, Eq)]
21pub enum Stop {
22 Exceeded(Exceeded),
24 Cancelled,
26 TimedOut,
28}
29
30impl Stop {
31 pub fn to_diagnostic(&self) -> Diagnostic {
33 match self {
34 Stop::Exceeded(exceeded) => exceeded.to_diagnostic(),
35 Stop::Cancelled => Diagnostic::new(codes::CALL_REQUEST_CANCELLED),
36 Stop::TimedOut => Diagnostic::new(codes::BUDGET_TIME_EXCEEDED),
37 }
38 }
39}
40
41impl From<Exceeded> for Stop {
42 fn from(exceeded: Exceeded) -> Self {
43 Stop::Exceeded(exceeded)
44 }
45}
46
47impl<'a> Cx<'a> {
48 pub fn new(budget: &'a mut Budget, diag: &'a mut Diagnostics, cancel: &'a CancelToken) -> Self {
50 Self {
51 budget,
52 diag,
53 cancel,
54 }
55 }
56
57 pub fn check(&mut self, kind: Kind, amount: u64) -> Result<(), Stop> {
59 if let Some(stop) = self.diag.collection_stop() {
60 return Err(stop);
61 }
62 if let Some(stop) = self.cancel.stop() {
63 return Err(stop);
64 }
65 self.budget.spend(kind, amount).map_err(Stop::from)
66 }
67
68 pub fn enter(&mut self) -> Result<(), Stop> {
70 self.check(Kind::Depth, 1)
71 }
72
73 pub fn leave(&mut self) {
75 self.budget.leave(1);
76 }
77
78 pub fn report(&mut self, diagnostic: Diagnostic) {
80 if self.diag.collection_stop().is_some() {
81 return;
82 }
83 if let Err(stop) = self
84 .diag
85 .preflight_event(&diagnostic, self.budget, self.cancel)
86 {
87 self.diag.stop_record_order(stop, diagnostic);
88 return;
89 }
90 if let Some(amount) = self.diag.record_order_work(&diagnostic)
91 && let Err(stop) = self.check(Kind::Work, amount)
92 {
93 self.diag.stop_record_order(stop, diagnostic);
94 return;
95 }
96 self.diag.record_event(&diagnostic);
97 self.diag.report(diagnostic);
98 }
99
100 pub fn with_diagnostic_events<T, E: From<Stop>>(
109 &mut self,
110 limit: u64,
111 operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
112 ) -> Result<(T, DiagnosticEvents), E> {
113 if let Err(stop) = self.enter() {
114 if self.diag.collection_stop().is_none() {
115 self.diag.stop_record_order(stop, stop.to_diagnostic());
116 }
117 return Err(stop.into());
118 }
119 let allocation = self.check(Kind::DecodedBytes, EventCapture::LOGICAL_BYTES);
120 if let Err(stop) = allocation {
121 self.leave();
122 if self.diag.collection_stop().is_none() {
123 self.diag.stop_record_order(stop, stop.to_diagnostic());
124 }
125 return Err(stop.into());
126 }
127 let parent = self.diag.events.take();
128 self.diag.events = Some(Box::new(EventCapture::new(limit, parent)));
129 let result = operation(self);
130 let stop = self.diag.collection_stop();
131 let capture = self.diag.events.take();
132 self.leave();
133 let Some(mut capture) = capture else {
134 return result.map(|value| (value, DiagnosticEvents::default()));
136 };
137 self.diag.events = capture.parent.take();
138 if let Some(stop) = stop {
139 return Err(stop.into());
140 }
141 let value = result?;
142 match capture.finish(self.budget, self.cancel) {
143 Ok(events) => Ok((value, events)),
144 Err(stop) => {
145 self.diag.stop_record_order(stop, stop.to_diagnostic());
146 Err(stop.into())
147 }
148 }
149 }
150
151 pub fn with_diagnostics_in_record_order<T, E: From<Stop>>(
160 &mut self,
161 operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
162 ) -> Result<T, E> {
163 if let Some(stop) = self.diag.collection_stop() {
164 return Err(stop.into());
165 }
166 if self.diag.is_collecting_in_record_order() {
167 let result = operation(self);
168 return match self.diag.collection_stop() {
169 Some(stop) => Err(stop.into()),
170 None => result,
171 };
172 }
173 let mut diagnostics = Diagnostics::in_record_order(self.diag.max_places());
174 diagnostics.events = self.diag.events.take();
175 let result = operation(&mut Cx::new(self.budget, &mut diagnostics, self.cancel));
176 let stop = diagnostics.collection_stop();
177 let events = diagnostics.events.take();
178 for diagnostic in diagnostics.into_vec() {
179 self.diag.report(diagnostic);
181 }
182 self.diag.events = events;
183 match stop {
184 Some(stop) => Err(stop.into()),
185 None => result,
186 }
187 }
188}
189
190#[derive(Clone, Debug)]
196pub struct Replay {
197 spent: [u64; Kind::ALL.len()],
199 depth_room: Option<u64>,
202 diagnostics: Diagnostics,
204}
205
206fn room(budget: &Budget, kind: Kind) -> Option<u64> {
208 match budget.limits().get(kind) {
209 Limit::Finite(limit) => Some(limit.saturating_sub(budget.used(kind))),
210 Limit::Unlimited => None,
211 }
212}
213
214impl Cx<'_> {
215 fn plain(&self) -> bool {
217 !self.diag.is_collecting_in_record_order() && self.diag.events.is_none()
218 }
219
220 pub fn record<T, E>(
230 &mut self,
231 operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
232 ) -> (Result<T, E>, Option<Replay>) {
233 if !self.plain() {
234 return (operation(self), None);
235 }
236 let before = Kind::ALL.map(|kind| self.budget.used(kind));
237 let depth_room = room(self.budget, Kind::Depth);
238 let mut diagnostics = Diagnostics::with_max_places(self.diag.max_places());
239 let result = operation(&mut Cx::new(self.budget, &mut diagnostics, self.cancel));
240 for diagnostic in diagnostics.iter() {
241 self.diag.report(diagnostic.clone());
242 }
243 let after = Kind::ALL.map(|kind| self.budget.used(kind));
244 let mut spent = [0; Kind::ALL.len()];
245 let mut recordable = result.is_ok() && self.budget.exceeded().is_none();
246 for (index, kind) in Kind::ALL.into_iter().enumerate() {
247 let (Some(&before), Some(&after), Some(slot)) =
248 (before.get(index), after.get(index), spent.get_mut(index))
249 else {
250 recordable = false;
251 break;
252 };
253 if after < before || after == u64::MAX || (kind == Kind::Depth && after != before) {
254 recordable = false;
255 break;
256 }
257 *slot = after - before;
258 }
259 let replay = recordable.then_some(Replay {
260 spent,
261 depth_room,
262 diagnostics,
263 });
264 (result, replay)
265 }
266
267 pub fn replay(&mut self, replay: &Replay) -> bool {
277 if !self.plain()
278 || self.diag.max_places() != replay.diagnostics.max_places()
279 || self.cancel.stop().is_some()
280 || self.budget.exceeded().is_some()
281 {
282 return false;
283 }
284 let depth = match (replay.depth_room, room(self.budget, Kind::Depth)) {
285 (Some(recorded), Some(now)) => now >= recorded,
286 (_, None) => true,
287 (None, Some(_)) => false,
288 };
289 if !depth {
290 return false;
291 }
292 let fits = Kind::ALL
293 .into_iter()
294 .zip(replay.spent)
295 .all(|(kind, spent)| room(self.budget, kind).is_none_or(|room| spent <= room));
296 if !fits {
297 return false;
298 }
299 for (kind, spent) in Kind::ALL.into_iter().zip(replay.spent) {
300 if spent > 0 && self.budget.spend(kind, spent).is_err() {
301 return false;
303 }
304 }
305 for diagnostic in replay.diagnostics.iter() {
306 self.diag.report(diagnostic.clone());
307 }
308 true
309 }
310}
311
312#[cfg(test)]
313mod tests {
314 use super::*;
315 use crate::budget::{Limit, Limits};
316 use crate::{Ref, Value};
317
318 fn event_at(record: u64) -> Diagnostic {
319 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
320 .with("name", record.to_string())
321 .at(Ref::at_record(record))
322 }
323
324 fn capture_events(limit: u64, records: &[u64]) -> DiagnosticEvents {
325 let mut budget = Budget::default();
326 let mut diag = Diagnostics::with_max_places(0);
327 let cancel = CancelToken::new();
328 Cx::new(&mut budget, &mut diag, &cancel)
329 .with_diagnostic_events(limit, |cx| {
330 for &record in records {
331 cx.report(event_at(record));
332 }
333 Ok::<(), Stop>(())
334 })
335 .unwrap()
336 .1
337 }
338
339 #[test]
340 fn event_limits_only_cut_details_and_preserve_the_earliest_summary_without_places() {
341 let full = capture_events(10, &[9, 3, 1, 3]);
342 assert_eq!(full.total, 4);
343 assert_eq!(full.counts.len(), 1);
344 assert_eq!(full.counts[0].count(), 4);
345 assert_eq!(full.counts[0].param("name"), Some(&Value::from("1")));
346 assert!(full.counts[0].places().is_empty());
347 assert!(!full.truncated);
348 for limit in [0, 1, 2] {
349 let events = capture_events(limit, &[9, 3, 1, 3]);
350 assert_eq!(events.total, full.total);
351 assert_eq!(events.counts, full.counts);
352 assert_eq!(events.details, full.details[..limit as usize]);
353 assert!(events.truncated);
354 }
355 }
356
357 #[test]
358 fn events_preserve_raw_places_and_same_place_reports_in_input_order() {
359 let mut budget = Budget::default();
360 let mut diag = Diagnostics::with_max_places(0);
361 let cancel = CancelToken::new();
362 let (_, events) = Cx::new(&mut budget, &mut diag, &cancel)
363 .with_diagnostic_events(8, |cx| {
364 cx.report(Diagnostic::new(codes::SXF_CODE_MISSING));
365 cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(Ref::at_bytes(2, 5)));
366 cx.report(
367 event_at(5)
368 .at(Ref::at_record(2).with_id("first"))
369 .at(Ref::at_bytes(1, 3)),
370 );
371 cx.report(
372 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
373 .with("id", 2_u64)
374 .at(Ref::at_record(2).with_id("first")),
375 );
376 Ok::<(), Stop>(())
377 })
378 .unwrap();
379 assert_eq!(events.total, 4);
380 assert_eq!(events.details.len(), 4);
381 assert_eq!(events.details[0].places().len(), 3);
382 assert_eq!(events.details[0].places()[0].record(), Some(5));
383 assert_eq!(events.details[0].places()[1].id(), Some("first"));
384 assert_eq!(events.details[1].code(), codes::SXF_P21_INSTANCE_DROPPED);
385 assert_eq!(events.details[2].places()[0].bytes().unwrap().start, 2);
386 assert_eq!(events.details[3].code(), codes::SXF_CODE_MISSING);
387 assert!(events.details[3].fidelity().is_none());
388 assert!(events.counts.iter().all(|entry| entry.places().is_empty()));
389 let codes: Vec<_> = events
390 .counts
391 .iter()
392 .map(|entry| entry.code().name())
393 .collect();
394 assert!(codes.windows(2).all(|pair| pair[0] <= pair[1]));
395 assert!(diag.iter().all(|entry| entry.places().is_empty()));
396 }
397
398 #[test]
399 fn nested_event_scopes_capture_each_raw_report_once_through_record_order() {
400 for max_places in [0, 1] {
401 let mut budget = Budget::default();
402 let mut diag = Diagnostics::with_max_places(max_places);
403 let cancel = CancelToken::new();
404 let (inner, outer) = Cx::new(&mut budget, &mut diag, &cancel)
405 .with_diagnostic_events(10, |cx| {
406 cx.report(event_at(9));
407 let inner = cx.with_diagnostics_in_record_order(|cx| {
408 cx.report(event_at(8));
409 let (_, inner) = cx.with_diagnostic_events(10, |cx| {
410 cx.report(event_at(5));
411 cx.with_diagnostics_in_record_order(|cx| {
412 cx.report(event_at(1));
413 Ok::<(), Stop>(())
414 })
415 })?;
416 cx.report(event_at(7));
417 Ok::<_, Stop>(inner)
418 })?;
419 cx.report(event_at(6));
420 Ok::<_, Stop>(inner)
421 })
422 .unwrap();
423 assert_eq!(outer.total, 6);
424 assert_eq!(outer.counts[0].count(), 6);
425 assert_eq!(outer.details.len(), 6);
426 assert_eq!(inner.total, 2);
427 assert_eq!(inner.counts[0].count(), 2);
428 assert_eq!(inner.details.len(), 2);
429 assert_eq!(diag.iter().next().unwrap().count(), 6);
430 assert_eq!(budget.used(Kind::Depth), 0);
431 }
432 }
433
434 #[test]
435 fn capture_inside_record_order_is_not_charged_for_reports_outside_the_scope() {
436 let mut budget = Budget::default();
437 let mut diag = Diagnostics::new();
438 let cancel = CancelToken::new();
439 let events = Cx::new(&mut budget, &mut diag, &cancel)
440 .with_diagnostics_in_record_order(|cx| {
441 cx.report(event_at(8));
442 let (_, events) = cx.with_diagnostic_events(1, |cx| {
443 cx.report(event_at(2));
444 Ok::<(), Stop>(())
445 })?;
446 cx.report(event_at(1));
447 Ok::<_, Stop>(events)
448 })
449 .unwrap();
450 assert_eq!(events.total, 1);
451 assert_eq!(events.details[0].places()[0].record(), Some(2));
452 assert_eq!(diag.iter().next().unwrap().count(), 3);
453 }
454
455 #[test]
456 fn event_totals_add_diagnostic_counts_without_inventing_more_detail_rows() {
457 let mut grouped = Diagnostics::new();
458 for _ in 0..3 {
459 grouped.report(event_at(4));
460 }
461 let mut budget = Budget::default();
462 let mut diag = Diagnostics::new();
463 let cancel = CancelToken::new();
464 let (_, events) = Cx::new(&mut budget, &mut diag, &cancel)
465 .with_diagnostic_events(1, |cx| {
466 for diagnostic in grouped.into_vec() {
467 cx.report(diagnostic);
468 }
469 Ok::<(), Stop>(())
470 })
471 .unwrap();
472 assert_eq!(events.total, 3);
473 assert_eq!(events.details.len(), 1);
474 assert_eq!(events.details[0].count(), 3);
475 assert!(!events.truncated);
476 }
477
478 #[test]
479 fn event_scope_entry_stops_before_allocating_or_running_the_operation() {
480 for (kind, limit, cancelled) in [
481 (Kind::Depth, 0, false),
482 (Kind::DecodedBytes, EventCapture::LOGICAL_BYTES - 1, false),
483 (Kind::Work, 0, true),
484 ] {
485 let mut budget = Budget::new(Limits::default().with(kind, Limit::Finite(limit)));
486 let mut diag = Diagnostics::new();
487 let cancel = CancelToken::new();
488 if cancelled {
489 cancel.cancel();
490 }
491 let mut entered = false;
492 let stop = Cx::new(&mut budget, &mut diag, &cancel)
493 .with_diagnostic_events(1, |_| {
494 entered = true;
495 Ok::<(), Stop>(())
496 })
497 .unwrap_err();
498 assert!(!entered);
499 assert!(diag.events.is_none());
500 assert_eq!(diag.len(), 1);
501 assert_eq!(
502 diag.iter().next().unwrap().code(),
503 stop.to_diagnostic().code()
504 );
505 assert_eq!(budget.used(Kind::Depth), 0);
506 assert_eq!(budget.used(Kind::DecodedBytes), 0);
507 }
508 }
509
510 #[test]
511 fn the_last_report_keeps_a_sticky_stop_before_copying_the_event() {
512 for kind in [Kind::Work, Kind::DecodedBytes] {
513 let limit = if kind == Kind::DecodedBytes {
514 EventCapture::LOGICAL_BYTES
515 } else {
516 0
517 };
518 let mut budget = Budget::new(Limits::default().with(kind, Limit::Finite(limit)));
519 let mut diag = Diagnostics::new();
520 let cancel = CancelToken::new();
521 let stop = Cx::new(&mut budget, &mut diag, &cancel)
522 .with_diagnostic_events(1, |cx| {
523 cx.report(event_at(7));
524 let stop = cx.check(Kind::Work, 0).unwrap_err();
525 cx.report(stop.to_diagnostic());
526 Ok::<(), Stop>(())
527 })
528 .unwrap_err();
529 assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == kind));
530 assert_eq!(diag.len(), 1);
531 assert_eq!(diag.iter().next().unwrap().code(), kind.exceeded_code());
532 assert_eq!(diag.iter().next().unwrap().count(), 1);
533 assert_eq!(diag.iter().next().unwrap().places(), [Ref::at_record(7)]);
534 assert_eq!(budget.used(Kind::DecodedBytes), EventCapture::LOGICAL_BYTES);
535 }
536 }
537
538 #[test]
539 fn a_scope_stop_is_returned_even_if_the_operation_ignores_its_inner_result() {
540 let mut budget = Budget::new(Limits::default().with(Kind::Depth, Limit::Finite(1)));
541 let mut diag = Diagnostics::new();
542 let cancel = CancelToken::new();
543 let stop = Cx::new(&mut budget, &mut diag, &cancel)
544 .with_diagnostic_events(1, |cx| {
545 let inner = cx.with_diagnostic_events(1, |_| Ok::<(), Stop>(()));
546 assert!(inner.is_err());
547 Ok::<(), Stop>(())
548 })
549 .unwrap_err();
550 assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == Kind::Depth));
551 assert_eq!(diag.len(), 1);
552 assert_eq!(budget.used(Kind::Depth), 0);
553 }
554
555 #[test]
556 fn capture_checks_cancellation_and_work_after_reaching_the_detail_limit() {
557 for limit in [0, 1] {
558 let mut budget = Budget::default();
559 let mut diag = Diagnostics::with_max_places(0);
560 let cancel = CancelToken::new();
561 let stop = Cx::new(&mut budget, &mut diag, &cancel)
562 .with_diagnostic_events(limit, |cx| {
563 cx.report(event_at(9));
564 let before = cx.budget.used(Kind::Work);
565 cx.report(event_at(8));
566 assert!(cx.budget.used(Kind::Work) > before);
567 cancel.cancel();
568 cx.report(event_at(7));
569 Ok::<(), Stop>(())
570 })
571 .unwrap_err();
572 assert_eq!(stop, Stop::Cancelled);
573 assert_eq!(diag.len(), 2);
574 assert_eq!(diag.iter().next().unwrap().count(), 2);
575 }
576 }
577
578 #[test]
579 fn final_sorting_checks_the_budget_and_reports_its_stop() {
580 let mut before_finish = 0;
581 let mut budget = Budget::default();
582 let mut diag = Diagnostics::new();
583 let cancel = CancelToken::new();
584 Cx::new(&mut budget, &mut diag, &cancel)
585 .with_diagnostic_events(1, |cx| {
586 cx.report(event_at(1));
587 before_finish = cx.budget.used(Kind::Work);
588 Ok::<(), Stop>(())
589 })
590 .unwrap();
591 let mut budget =
592 Budget::new(Limits::default().with(Kind::Work, Limit::Finite(before_finish)));
593 let mut diag = Diagnostics::new();
594 let stop = Cx::new(&mut budget, &mut diag, &cancel)
595 .with_diagnostic_events(1, |cx| {
596 cx.report(event_at(1));
597 Ok::<(), Stop>(())
598 })
599 .unwrap_err();
600 assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == Kind::Work));
601 assert_eq!(diag.len(), 2);
602 assert_eq!(
603 diag.iter().last().unwrap().code(),
604 codes::BUDGET_WORK_EXCEEDED
605 );
606 }
607
608 #[test]
609 fn merging_captures_keeps_counts_and_the_earliest_summary_without_recapturing() {
610 for limit in [0, 1, 4] {
611 let first = capture_events(limit, &[9, 5]);
612 let second = capture_events(limit, &[1, 5]);
613 let mut budget = Budget::default();
614 let mut diag = Diagnostics::new();
615 let cancel = CancelToken::new();
616 let (merged, surrounding) = Cx::new(&mut budget, &mut diag, &cancel)
617 .with_diagnostic_events(10, |cx| first.merge(second, limit, cx))
618 .unwrap();
619 assert_eq!(merged.total, 4);
620 assert_eq!(merged.counts[0].count(), 4);
621 assert_eq!(merged.counts[0].param("name"), Some(&Value::from("1")));
622 assert!(merged.counts[0].places().is_empty());
623 assert_eq!(merged.details.len(), (limit as usize).min(4));
624 assert_eq!(merged.truncated, limit < 4);
625 assert_eq!(surrounding.total, 0);
626 assert!(diag.is_empty());
627 }
628 }
629
630 #[test]
631 fn merging_captures_checks_its_budget_before_allocating_and_does_not_restore_cut_details() {
632 let first = capture_events(0, &[9]);
633 let second = capture_events(0, &[1]);
634 let mut budget = Budget::default();
635 let mut diag = Diagnostics::new();
636 let cancel = CancelToken::new();
637 let merged = first
638 .merge(second, 10, &mut Cx::new(&mut budget, &mut diag, &cancel))
639 .unwrap();
640 assert_eq!(merged.total, 2);
641 assert!(merged.details.is_empty());
642 assert!(merged.truncated);
643 let mut budget = Budget::new(Limits::default().with(Kind::DecodedBytes, Limit::Finite(0)));
644 let first = capture_events(1, &[9]);
645 let second = capture_events(1, &[1]);
646 let stop = first
647 .merge(second, 1, &mut Cx::new(&mut budget, &mut diag, &cancel))
648 .unwrap_err();
649 assert!(matches!(stop, Stop::Exceeded(exceeded) if exceeded.kind == Kind::DecodedBytes));
650 assert_eq!(budget.used(Kind::DecodedBytes), 0);
651 assert_eq!(
652 diag.iter().next().unwrap().code(),
653 codes::BUDGET_DECODED_BYTES_EXCEEDED
654 );
655 }
656
657 #[test]
658 fn event_counts_use_catalog_keys_and_input_position_for_representative_values() {
659 let mut budget = Budget::default();
660 let mut diag = Diagnostics::with_max_places(0);
661 let cancel = CancelToken::new();
662 let (_, events) = Cx::new(&mut budget, &mut diag, &cancel)
663 .with_diagnostic_events(0, |cx| {
664 for (kind, code, record, value) in [
665 ("line", 2_i64, 9, "late"),
666 ("line", 2, 1, "early"),
667 ("line", 1, 4, "one"),
668 ("circle", 4, 5, "circle"),
669 ] {
670 cx.report(
671 Diagnostic::new(codes::SXF_CODE_MISSING)
672 .with("kind", kind)
673 .with("code", code)
674 .with("value", value)
675 .at(Ref::at_record(record)),
676 );
677 }
678 Ok::<(), Stop>(())
679 })
680 .unwrap();
681 assert_eq!(events.total, 4);
682 assert_eq!(events.counts.len(), 3);
683 assert_eq!(events.counts[0].param("kind"), Some(&Value::from("circle")));
684 assert_eq!(events.counts[1].param("code"), Some(&Value::Int(1)));
685 assert_eq!(events.counts[2].count(), 2);
686 assert_eq!(events.counts[2].param("value"), Some(&Value::from("early")));
687 assert!(events.details.is_empty());
688 }
689
690 #[test]
691 fn merging_same_position_reports_preserves_the_phase_order_and_representative() {
692 let mut budget = Budget::default();
693 let mut diag = Diagnostics::with_max_places(0);
694 let cancel = CancelToken::new();
695 let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
696 let mut phase = |name: &str| {
697 cx.with_diagnostic_events(2, |cx| {
698 cx.report(event_at(1).with("name", name));
699 Ok::<(), Stop>(())
700 })
701 .unwrap()
702 .1
703 };
704 let first = phase("first");
705 let second = phase("second");
706 let merged = first.merge(second, 2, &mut cx).unwrap();
707 assert_eq!(merged.total, 2);
708 assert_eq!(merged.counts[0].count(), 2);
709 assert_eq!(merged.counts[0].param("name"), Some(&Value::from("first")));
710 assert_eq!(merged.details[0].param("name"), Some(&Value::from("first")));
711 assert_eq!(
712 merged.details[1].param("name"),
713 Some(&Value::from("second"))
714 );
715 assert!(!merged.truncated);
716 }
717
718 #[test]
719 fn checks_the_signal_before_the_budget() {
720 let mut budget = Budget::default();
721 let mut diag = Diagnostics::new();
722 let cancel = CancelToken::new();
723 let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
724 assert_eq!(cx.check(Kind::Records, 1), Ok(()));
725 cancel.cancel();
726 assert_eq!(cx.check(Kind::Records, 1), Err(Stop::Cancelled));
727 assert_eq!(budget.used(Kind::Records), 1);
728 }
729
730 #[test]
731 fn nesting_stops_at_the_depth_limit() {
732 let mut budget = Budget::new(Limits::default().with(Kind::Depth, Limit::Finite(1)));
733 let mut diag = Diagnostics::new();
734 let cancel = CancelToken::new();
735 let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
736 assert_eq!(cx.enter(), Ok(()));
737 let stop = cx.enter().unwrap_err();
738 cx.report(stop.to_diagnostic());
739 cx.leave();
740 assert_eq!(
741 diag.iter().next().map(Diagnostic::code),
742 Some(codes::BUDGET_DEPTH_EXCEEDED)
743 );
744 }
745
746 #[test]
747 fn each_stop_has_its_code() {
748 assert_eq!(
749 Stop::Cancelled.to_diagnostic().code(),
750 codes::CALL_REQUEST_CANCELLED
751 );
752 assert_eq!(
753 Stop::TimedOut.to_diagnostic().code(),
754 codes::BUDGET_TIME_EXCEEDED
755 );
756 }
757
758 #[test]
759 fn record_order_keeps_first_places_values_and_stable_ties_even_without_places() {
760 for max_places in [0, 1, 2, 16] {
761 let mut budget = Budget::default();
762 let mut diag = Diagnostics::with_max_places(max_places);
763 let cancel = CancelToken::new();
764 Cx::new(&mut budget, &mut diag, &cancel)
765 .with_diagnostics_in_record_order(|cx| {
766 cx.report(
767 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
768 .with("name", "late")
769 .at(crate::Ref::at_record(9)),
770 );
771 cx.report(
772 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
773 .with("id", 2_u64)
774 .at(crate::Ref::at_record(4)),
775 );
776 cx.report(
777 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
778 .with("name", "first")
779 .at(crate::Ref::at_record(4)),
780 );
781 cx.report(
782 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
783 .with("id", 1_u64)
784 .at(crate::Ref::at_record(4)),
785 );
786 cx.report(
787 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
788 .with("name", "middle")
789 .at(crate::Ref::at_record(7)),
790 );
791 assert!(cx.diag.iter().all(|d| d.places().len() <= max_places));
793 Ok::<(), Stop>(())
794 })
795 .unwrap();
796 let diagnostics = diag.into_vec();
797 assert_eq!(diagnostics.len(), 3);
798 assert_eq!(diagnostics[0].param("id"), Some(&crate::Value::UInt(2)));
799 assert_eq!(diagnostics[2].param("id"), Some(&crate::Value::UInt(1)));
800 let merged = &diagnostics[1];
801 assert_eq!(merged.code(), codes::ZIP_PATH_UNSAFE);
802 assert_eq!(merged.count(), 3);
803 assert_eq!(merged.param("name"), Some(&crate::Value::from("first")));
804 assert_eq!(
805 merged.places(),
806 &[
807 crate::Ref::at_record(4),
808 crate::Ref::at_record(7),
809 crate::Ref::at_record(9)
810 ][..max_places.min(3)]
811 );
812 }
813 }
814
815 #[test]
816 fn record_order_stops_before_collecting_and_flushes_already_paid_diagnostics() {
817 for cancelled in [false, true] {
818 let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(5)));
819 let mut diag = Diagnostics::with_max_places(1);
820 let cancel = CancelToken::new();
821 let result =
822 Cx::new(&mut budget, &mut diag, &cancel).with_diagnostics_in_record_order(|cx| {
823 cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(9)));
824 if cancelled {
825 cancel.cancel();
826 }
827 cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(3)));
828 let stop = cx.check(Kind::Work, 0).unwrap_err();
830 cx.report(stop.to_diagnostic());
831 Ok::<(), Stop>(())
832 });
833 let stop = result.unwrap_err();
834 assert_eq!(cancelled, stop == Stop::Cancelled);
835 assert_eq!(budget.used(Kind::Work), 5);
836 let diagnostics = diag.into_vec();
837 assert_eq!(diagnostics.len(), 2);
838 assert_eq!(diagnostics[0].code(), stop.to_diagnostic().code());
839 assert_eq!(diagnostics[0].places(), [crate::Ref::at_record(3)]);
840 assert_eq!(diagnostics[1].count(), 1);
841 assert_eq!(diagnostics[1].places(), [crate::Ref::at_record(9)]);
842 }
843 }
844
845 #[test]
846 fn ordinary_reporting_neither_reorders_nor_spends_work() {
847 let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(0)));
848 let mut diag = Diagnostics::with_max_places(1);
849 let cancel = CancelToken::new();
850 let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
851 for record in [9, 3] {
852 cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(record)));
853 }
854 assert_eq!(budget.used(Kind::Work), 0);
855 assert_eq!(
856 diag.iter().next().unwrap().places(),
857 [crate::Ref::at_record(9)]
858 );
859 assert_eq!(diag.iter().next().unwrap().count(), 2);
860 }
861
862 #[test]
863 fn repeated_reports_keep_bounded_storage() {
864 for max_places in [0, 1] {
865 let mut budget = Budget::default();
866 let mut diag = Diagnostics::with_max_places(max_places);
867 let cancel = CancelToken::new();
868 Cx::new(&mut budget, &mut diag, &cancel)
869 .with_diagnostics_in_record_order(|cx| {
870 for record in (0..1000).rev() {
871 cx.report(
872 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
873 .at(crate::Ref::at_record(record)),
874 );
875 assert_eq!(cx.diag.len(), 1);
876 assert_eq!(cx.diag.iter().next().unwrap().places().len(), max_places);
877 }
878 Ok::<(), Stop>(())
879 })
880 .unwrap();
881 let diagnostics = diag.into_vec();
882 assert_eq!(diagnostics[0].count(), 1000);
883 assert_eq!(
884 diagnostics[0].places(),
885 &[crate::Ref::at_record(0)][..max_places]
886 );
887 assert_eq!(budget.used(Kind::Work), 1000 * (4 + max_places as u64));
888 }
889 }
890
891 #[test]
892 fn record_order_preserves_tied_places_and_puts_unlocated_reports_last() {
893 let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(22)));
894 let mut diag = Diagnostics::with_max_places(2);
895 let cancel = CancelToken::new();
896 Cx::new(&mut budget, &mut diag, &cancel)
897 .with_diagnostics_in_record_order(|cx| {
898 cx.report(Diagnostic::new(codes::SXF_P21_SHEET_MISSING));
899 cx.report(
900 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
901 .at(crate::Ref::at_record(5))
902 .at(crate::Ref::at_record(2).with_id("first"))
903 .at(crate::Ref::at_record(2).with_id("second")),
904 );
905 cx.report(
906 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
907 .at(crate::Ref::at_record(2).with_id("third")),
908 );
909 Ok::<(), Stop>(())
910 })
911 .unwrap();
912 assert_eq!(budget.used(Kind::Work), 22);
913 let diagnostics = diag.into_vec();
914 assert_eq!(diagnostics[0].count(), 2);
915 assert_eq!(
916 diagnostics[0].places(),
917 [
918 crate::Ref::at_record(2).with_id("first"),
919 crate::Ref::at_record(2).with_id("second")
920 ]
921 );
922 assert_eq!(diagnostics[1].code(), codes::SXF_P21_SHEET_MISSING);
923 assert!(diagnostics[1].places().is_empty());
924 }
925
926 #[test]
927 fn nested_record_order_keeps_positions_values_and_one_work_charge() {
928 for max_places in [0, 1] {
929 let work = 5 * (4 + max_places as u64);
930 let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(work)));
931 let mut diag = Diagnostics::with_max_places(max_places);
932 let cancel = CancelToken::new();
933 Cx::new(&mut budget, &mut diag, &cancel)
934 .with_diagnostics_in_record_order(|cx| {
935 cx.report(
936 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
937 .with("name", "late")
938 .at(crate::Ref::at_record(9)),
939 );
940 cx.with_diagnostics_in_record_order(|cx| {
941 cx.report(
942 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
943 .with("id", 2_u64)
944 .at(crate::Ref::at_record(4)),
945 );
946 cx.with_diagnostics_in_record_order(|cx| {
947 cx.report(
948 Diagnostic::new(codes::ZIP_PATH_UNSAFE)
949 .with("name", "first")
950 .at(crate::Ref::at_record(1)),
951 );
952 Ok::<(), Stop>(())
953 })?;
954 cx.report(
955 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
956 .with("id", 3_u64)
957 .at(crate::Ref::at_record(4)),
958 );
959 Ok::<(), Stop>(())
960 })?;
961 cx.report(
962 Diagnostic::new(codes::SXF_P21_SHEET_DROPPED)
963 .with("id", 80_u64)
964 .at(crate::Ref::at_record(2)),
965 );
966 Ok::<(), Stop>(())
967 })
968 .unwrap();
969 assert_eq!(budget.used(Kind::Work), work);
970 let diagnostics = diag.into_vec();
971 assert_eq!(diagnostics.len(), 4);
972 assert_eq!(diagnostics[0].code(), codes::ZIP_PATH_UNSAFE);
973 assert_eq!(diagnostics[0].count(), 2);
974 assert_eq!(
975 diagnostics[0].param("name"),
976 Some(&crate::Value::from("first"))
977 );
978 assert_eq!(diagnostics[1].code(), codes::SXF_P21_SHEET_DROPPED);
979 assert_eq!(diagnostics[2].param("id"), Some(&crate::Value::UInt(2)));
980 assert_eq!(diagnostics[3].param("id"), Some(&crate::Value::UInt(3)));
981 for (diagnostic, record) in diagnostics.iter().zip([1, 2, 4, 4]) {
982 assert_eq!(
983 diagnostic.places(),
984 &[crate::Ref::at_record(record)][..max_places]
985 );
986 }
987 }
988 }
989
990 #[test]
991 fn nested_record_order_returns_the_inner_stop_and_keeps_collected_reports() {
992 for (max_places, cancelled) in [(0, false), (1, false), (0, true), (1, true)] {
993 let work = 2 * (4 + max_places as u64);
994 let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(work)));
995 let mut diag = Diagnostics::with_max_places(max_places);
996 let cancel = CancelToken::new();
997 let mut inner_stop = None;
998 let result =
999 Cx::new(&mut budget, &mut diag, &cancel).with_diagnostics_in_record_order(|cx| {
1000 cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(9)));
1001 let result = cx.with_diagnostics_in_record_order(|cx| {
1002 cx.report(
1003 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
1004 .with("id", 2_u64)
1005 .at(crate::Ref::at_record(3)),
1006 );
1007 if cancelled {
1008 cancel.cancel();
1009 }
1010 cx.report(
1011 Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
1012 .with("id", 3_u64)
1013 .at(crate::Ref::at_record(5)),
1014 );
1015 Ok::<(), Stop>(())
1016 });
1017 let stop = result.unwrap_err();
1018 inner_stop = Some(stop);
1019 assert_eq!(cx.check(Kind::Work, 0), Err(stop));
1020 let mut entered = false;
1021 let after_stop = cx.with_diagnostics_in_record_order(|_| {
1022 entered = true;
1023 Ok::<(), Stop>(())
1024 });
1025 assert_eq!(after_stop, Err(stop));
1026 assert!(!entered);
1027 Ok::<(), Stop>(())
1029 });
1030 let stop = result.unwrap_err();
1031 assert_eq!(inner_stop, Some(stop));
1032 assert_eq!(cancelled, stop == Stop::Cancelled);
1033 assert_eq!(budget.used(Kind::Work), work);
1034 let diagnostics = diag.into_vec();
1035 assert_eq!(diagnostics.len(), 3);
1036 assert_eq!(diagnostics[0].code(), codes::SXF_P21_INSTANCE_DROPPED);
1037 assert_eq!(diagnostics[0].param("id"), Some(&crate::Value::UInt(2)));
1038 assert_eq!(diagnostics[1].code(), stop.to_diagnostic().code());
1039 assert_eq!(diagnostics[2].code(), codes::ZIP_PATH_UNSAFE);
1040 for (diagnostic, record) in diagnostics.iter().zip([3, 5, 9]) {
1041 assert_eq!(diagnostic.count(), 1);
1042 assert_eq!(
1043 diagnostic.places(),
1044 &[crate::Ref::at_record(record)][..max_places]
1045 );
1046 }
1047 }
1048 }
1049
1050 fn mixed(cx: &mut Cx<'_>) -> Result<u32, Stop> {
1052 cx.report(event_at(7));
1053 for record in 0..5 {
1054 cx.check(Kind::Records, 1)?;
1055 cx.report(Diagnostic::new(codes::SXF_CODE_MISSING).at(Ref::at_record(record)));
1056 }
1057 cx.enter()?;
1058 cx.enter()?;
1059 cx.check(Kind::Work, 3)?;
1060 cx.leave();
1061 cx.leave();
1062 cx.with_diagnostics_in_record_order(|cx| {
1063 cx.report(event_at(9));
1064 cx.check(Kind::Work, 2)?;
1065 cx.report(event_at(1));
1066 Ok::<(), Stop>(())
1067 })?;
1068 let mut quiet = Diagnostics::new();
1069 let mut inner = Cx::new(cx.budget, &mut quiet, cx.cancel);
1070 inner.check(Kind::Elements, 4)?;
1071 inner.report(event_at(2));
1072 cx.check(Kind::DecodedBytes, 10)?;
1073 Ok(42)
1074 }
1075
1076 fn started(limits: Limits, max_places: usize) -> (Budget, Diagnostics) {
1078 let mut budget = Budget::new(limits);
1079 budget.spend(Kind::Work, 5).unwrap();
1080 let mut diag = Diagnostics::with_max_places(max_places);
1081 diag.report(Diagnostic::new(codes::SXF_CODE_MISSING).at(Ref::at_record(100)));
1082 diag.report(event_at(3));
1083 (budget, diag)
1084 }
1085
1086 fn recorded(max_places: usize) -> Replay {
1087 let (mut budget, mut diag) = started(Limits::default(), max_places);
1088 let cancel = CancelToken::new();
1089 let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(mixed);
1090 assert_eq!(result, Ok(42));
1091 replay.unwrap()
1092 }
1093
1094 #[test]
1095 fn recording_and_replaying_match_running_the_operation_again() {
1096 for max_places in [0, 2, Diagnostics::DEFAULT_MAX_PLACES] {
1097 let cancel = CancelToken::new();
1098 let (mut budget, mut diag) = started(Limits::default(), max_places);
1099 assert_eq!(mixed(&mut Cx::new(&mut budget, &mut diag, &cancel)), Ok(42));
1100 let expected = (budget, diag.into_vec());
1101
1102 let (mut budget, mut diag) = started(Limits::default(), max_places);
1103 let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(mixed);
1104 assert_eq!(result, Ok(42));
1105 assert_eq!((budget, diag.into_vec()), expected);
1106
1107 let replay = replay.unwrap();
1108 let (mut budget, mut diag) = started(Limits::default(), max_places);
1109 assert!(Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1110 assert_eq!((budget.clone(), diag.clone().into_vec()), expected);
1111 let (mut twice_budget, mut twice_diag) = started(Limits::default(), max_places);
1113 for _ in 0..2 {
1114 let mut cx = Cx::new(&mut twice_budget, &mut twice_diag, &cancel);
1115 assert_eq!(mixed(&mut cx), Ok(42));
1116 }
1117 assert!(Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1118 assert_eq!(
1119 (budget, diag.into_vec()),
1120 (twice_budget, twice_diag.into_vec())
1121 );
1122 }
1123 }
1124
1125 #[test]
1126 fn replay_refuses_budgets_that_would_stop_the_operation_and_changes_nothing() {
1127 let replay = recorded(Diagnostics::DEFAULT_MAX_PLACES);
1128 let cancel = CancelToken::new();
1129 let (mut budget, mut diag) = started(Limits::default(), 16);
1131 let used = Kind::ALL.map(|kind| budget.used(kind));
1132 mixed(&mut Cx::new(&mut budget, &mut diag, &cancel)).unwrap();
1133 assert!(budget.used(Kind::Work) > 5 + 5);
1134 for (kind, used) in Kind::ALL.into_iter().zip(used) {
1135 let spent = budget.used(kind) - used;
1136 if spent == 0 {
1137 continue;
1138 }
1139 for (limit, accepted) in [(used + spent - 1, false), (used + spent, true)] {
1140 let limits = Limits::default().with(kind, Limit::Finite(limit));
1141 let (mut budget, mut diag) = started(limits, 16);
1142 let before = (budget.clone(), diag.clone().into_vec());
1143 let replayed = Cx::new(&mut budget, &mut diag, &cancel).replay(&replay);
1144 assert_eq!(replayed, accepted, "{kind:?} {limit}");
1145 if !accepted {
1146 assert_eq!((budget, diag.into_vec()), before);
1147 let (mut budget, mut diag) = started(limits, 16);
1149 let stop = mixed(&mut Cx::new(&mut budget, &mut diag, &cancel));
1150 assert!(matches!(stop, Err(Stop::Exceeded(e)) if e.kind == kind));
1151 }
1152 }
1153 }
1154 for (limit, accepted) in [
1156 (Limit::Finite(255), false),
1157 (Limit::Finite(256), true),
1158 (Limit::Unlimited, true),
1159 ] {
1160 let (mut budget, mut diag) = started(Limits::default().with(Kind::Depth, limit), 16);
1161 let replayed = Cx::new(&mut budget, &mut diag, &cancel).replay(&replay);
1162 assert_eq!(replayed, accepted, "{limit:?}");
1163 }
1164 let cancelled = CancelToken::new();
1166 cancelled.cancel();
1167 let (mut budget, mut diag) = started(Limits::default(), 16);
1168 assert!(!Cx::new(&mut budget, &mut diag, &cancelled).replay(&replay));
1169 assert_eq!(budget.used(Kind::Records), 0);
1170 let (mut budget, mut diag) = started(Limits::default(), 16);
1171 assert!(budget.spend(Kind::Work, u64::MAX).is_err());
1172 assert!(!Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1173 let (mut budget, mut diag) = started(Limits::default(), 15);
1174 assert!(!Cx::new(&mut budget, &mut diag, &cancel).replay(&replay));
1175 assert_eq!(diag.len(), 2);
1176 }
1177
1178 #[test]
1179 fn replay_and_record_step_aside_inside_ordered_or_captured_collection() {
1180 let replay = recorded(Diagnostics::DEFAULT_MAX_PLACES);
1181 let cancel = CancelToken::new();
1182 let (mut budget, mut diag) = started(Limits::default(), 16);
1183 let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
1184 cx.with_diagnostics_in_record_order(|cx| {
1185 assert!(!cx.replay(&replay));
1186 let (result, recorded) = cx.record(mixed);
1187 assert_eq!(result, Ok(42));
1188 assert!(recorded.is_none());
1189 Ok::<(), Stop>(())
1190 })
1191 .unwrap();
1192 cx.with_diagnostic_events(4, |cx| {
1193 assert!(!cx.replay(&replay));
1194 assert!(cx.record(mixed).1.is_none());
1195 Ok::<(), Stop>(())
1196 })
1197 .unwrap();
1198 }
1199
1200 #[test]
1201 fn record_keeps_only_operations_that_finish_with_balanced_depth() {
1202 let cancel = CancelToken::new();
1203 for work in 5..12 {
1205 let limits = Limits::default().with(Kind::Work, Limit::Finite(work));
1206 let (mut budget, mut diag) = started(limits, 2);
1207 let result = mixed(&mut Cx::new(&mut budget, &mut diag, &cancel));
1208 let expected = (result, budget, diag.into_vec());
1209 let (mut budget, mut diag) = started(limits, 2);
1210 let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(mixed);
1211 assert_eq!(replay.is_some(), result.is_ok());
1212 assert_eq!((result, budget, diag.into_vec()), expected);
1213 }
1214 let (mut budget, mut diag) = started(Limits::default(), 2);
1215 let (result, replay) = Cx::new(&mut budget, &mut diag, &cancel).record(|cx| cx.enter());
1216 assert_eq!(result, Ok(()));
1217 assert!(replay.is_none());
1218 }
1219}