1#![doc = include_str!("../README.md")]
2#![warn(missing_docs)]
3
4mod convention;
34mod error;
35#[cfg(feature = "jsonl")]
36mod jsonl;
37#[cfg(feature = "live")]
38mod recorder;
39#[cfg(feature = "tokio")]
40pub mod tokio;
42mod types;
43
44use std::collections::{BTreeMap, BTreeSet};
45use tailtriage_core::{
46 BuildError, QueueEvent, RequestEvent, RunBuilder, RunBuilderOptions, StageEvent,
47};
48
49pub use convention::{
50 TT_DEPTH_AT_START, TT_KIND, TT_OUTCOME, TT_QUEUE, TT_REQUEST_ID, TT_ROUTE, TT_STAGE, TT_SUCCESS,
51};
52pub use error::ImportError;
53#[cfg(feature = "jsonl")]
54pub use jsonl::{
55 import_jsonl_path, import_jsonl_path_with_mode, import_jsonl_reader,
56 import_jsonl_reader_with_mode, JsonlParseMode,
57};
58#[cfg(feature = "live")]
59pub use recorder::{
60 RecorderLimits, TailtriageLayer, TracingIntakeSession, TracingIntakeSessionBuilder,
61 TracingRecorder, TracingRecorderBuilder, DEFAULT_MAX_COMPLETED_CANDIDATE_SPANS,
62 DEFAULT_MAX_OPEN_SPANS,
63};
64pub use types::{FieldValue, ImportOptions, ImportWarning, ImportedRun, SpanKind, SpanRecord};
65
66pub fn ensure_persistable_run_has_requests(run: &tailtriage_core::Run) -> Result<(), ImportError> {
72 if run.requests.is_empty() {
73 return Err(ImportError::ZeroRequestArtifact {
74 guidance: persistable_zero_request_guidance(),
75 });
76 }
77 Ok(())
78}
79
80#[allow(dead_code)]
81pub(crate) fn ensure_persistable_run_with_warnings(
82 run: &tailtriage_core::Run,
83 warnings: &[ImportWarning],
84) -> Result<(), ImportError> {
85 if run.requests.is_empty() {
86 let guidance = persistable_zero_request_guidance();
87 let warning_messages = warnings
88 .iter()
89 .map(|w| w.message().to_owned())
90 .collect::<Vec<_>>();
91 if warning_messages.is_empty() {
92 return Err(ImportError::ZeroRequestArtifact { guidance });
93 }
94 return Err(ImportError::ZeroRequestArtifactWithWarnings {
95 guidance,
96 warnings: warning_messages,
97 });
98 }
99 ensure_persistable_run_has_requests(run)
100}
101
102pub(crate) fn persistable_zero_request_guidance() -> String {
103 "tracing import produced zero request events; persisted Run JSON artifacts intended for tailtriage analyze require at least one completed tt.kind=\"request\" span with tt.request_id, tt.route, and explicit unix-ms timing fields (started_at_unix_ms/finished_at_unix_ms).".to_owned()
104}
105
106#[allow(clippy::too_many_lines, clippy::needless_pass_by_value)]
118pub fn run_from_span_records<I>(
119 spans: I,
120 options: ImportOptions,
121) -> Result<ImportedRun, ImportError>
122where
123 I: IntoIterator<Item = SpanRecord>,
124{
125 validate_service_name(options.service_name())?;
126 let mut warnings = Vec::new();
127 let mut parsed_requests = Vec::new();
128 let mut parsed_stages = Vec::new();
129 let mut queues = Vec::new();
130
131 for span in spans {
132 let kind = match get_string_field_state(&span, TT_KIND) {
133 StringFieldState::Missing => {
134 if span_has_tailtriage_field(&span) {
135 strict_or_warn(
136 options.strict_mode(),
137 &mut warnings,
138 format!(
139 "missing required field '{TT_KIND}' in span '{}'",
140 span.name()
141 ),
142 )?;
143 }
144 continue;
145 }
146 StringFieldState::Value(kind) => {
147 let Some(kind) = SpanKind::parse(kind) else {
148 strict_or_warn(
149 options.strict_mode(),
150 &mut warnings,
151 format!("unknown tt.kind '{kind}' in span '{}'", span.name()),
152 )?;
153 continue;
154 };
155 kind
156 }
157 StringFieldState::InvalidType => {
158 strict_or_warn(
159 options.strict_mode(),
160 &mut warnings,
161 format!(
162 "invalid field '{TT_KIND}' in span '{}': expected string",
163 span.name()
164 ),
165 )?;
166 continue;
167 }
168 };
169
170 if span.finished_at_unix_ms() < span.started_at_unix_ms() {
171 let message = format!(
172 "skipped span '{}' due to inverted timestamps: start={} finish={}",
173 span.name(),
174 span.started_at_unix_ms(),
175 span.finished_at_unix_ms()
176 );
177 strict_or_warn(options.strict_mode(), &mut warnings, message)?;
178 continue;
179 }
180
181 match kind {
182 SpanKind::Request => {
183 let request_id =
184 required_string(&span, TT_REQUEST_ID, options.strict_mode(), &mut warnings)?;
185 let route = required_string(&span, TT_ROUTE, options.strict_mode(), &mut warnings)?;
186 if let (Some(request_id), Some(route)) = (request_id, route) {
187 let Some((outcome, outcome_defaulted)) =
188 parse_outcome(&span, options.strict_mode(), &mut warnings)?
189 else {
190 continue;
191 };
192 let (started_at_run_us, finished_at_run_us) = sanitized_run_relative_offsets(
193 &span,
194 options.strict_mode(),
195 &mut warnings,
196 )?;
197 parsed_requests.push(ParsedRequestEvent {
198 event: RequestEvent {
199 request_id,
200 route,
201 kind: None,
202 started_at_unix_ms: span.started_at_unix_ms(),
203 started_at_run_us,
204 finished_at_unix_ms: span.finished_at_unix_ms(),
205 finished_at_run_us,
206 latency_us: elapsed_duration_us(
207 &span,
208 started_at_run_us,
209 finished_at_run_us,
210 options.strict_mode(),
211 &mut warnings,
212 )?,
213 outcome,
214 },
215 outcome_defaulted,
216 });
217 }
218 }
219 SpanKind::Stage => {
220 let request_id =
221 required_string(&span, TT_REQUEST_ID, options.strict_mode(), &mut warnings)?;
222 let stage = required_string(&span, TT_STAGE, options.strict_mode(), &mut warnings)?;
223 if let (Some(request_id), Some(stage)) = (request_id, stage) {
224 let success_field = parse_success(&span, options.strict_mode(), &mut warnings)?;
225 let success = match success_field {
226 OptionalField::Missing => true,
227 OptionalField::Value(success) => success,
228 OptionalField::Invalid => continue,
229 };
230 let (started_at_run_us, finished_at_run_us) = sanitized_run_relative_offsets(
231 &span,
232 options.strict_mode(),
233 &mut warnings,
234 )?;
235 parsed_stages.push(ParsedStageEvent {
236 event: StageEvent {
237 request_id,
238 stage,
239 started_at_unix_ms: span.started_at_unix_ms(),
240 started_at_run_us,
241 finished_at_unix_ms: span.finished_at_unix_ms(),
242 finished_at_run_us,
243 latency_us: elapsed_duration_us(
244 &span,
245 started_at_run_us,
246 finished_at_run_us,
247 options.strict_mode(),
248 &mut warnings,
249 )?,
250 success,
251 },
252 success_defaulted: matches!(success_field, OptionalField::Missing),
253 });
254 }
255 }
256 SpanKind::Queue => {
257 let request_id =
258 required_string(&span, TT_REQUEST_ID, options.strict_mode(), &mut warnings)?;
259 let queue = required_string(&span, TT_QUEUE, options.strict_mode(), &mut warnings)?;
260 if let (Some(request_id), Some(queue)) = (request_id, queue) {
261 let depth_at_start =
262 match parse_depth_at_start(&span, options.strict_mode(), &mut warnings)? {
263 OptionalField::Missing => None,
264 OptionalField::Value(depth) => Some(depth),
265 OptionalField::Invalid => continue,
266 };
267 let (waited_from_run_us, waited_until_run_us) = sanitized_run_relative_offsets(
268 &span,
269 options.strict_mode(),
270 &mut warnings,
271 )?;
272 queues.push(QueueEvent {
273 request_id,
274 queue,
275 waited_from_unix_ms: span.started_at_unix_ms(),
276 waited_from_run_us,
277 waited_until_unix_ms: span.finished_at_unix_ms(),
278 waited_until_run_us,
279 wait_us: elapsed_duration_us(
280 &span,
281 waited_from_run_us,
282 waited_until_run_us,
283 options.strict_mode(),
284 &mut warnings,
285 )?,
286 depth_at_start,
287 });
288 }
289 }
290 }
291 }
292 let mode = options.mode_value();
293 let capture_limits = options.resolved_capture_limits();
294 dedupe_retained_requests(
295 &mut parsed_requests,
296 capture_limits.max_requests,
297 options.strict_mode(),
298 &mut warnings,
299 )?;
300 let request_outcome_default_count = parsed_requests
301 .iter()
302 .take(capture_limits.max_requests)
303 .filter(|request| request.outcome_defaulted)
304 .count();
305 if request_outcome_default_count > 0 {
306 warnings.push(ImportWarning::new(format!(
307 "{request_outcome_default_count} request span(s) missing optional '{TT_OUTCOME}'; assumed 'ok'"
308 )));
309 }
310 let requests: Vec<RequestEvent> = parsed_requests
311 .into_iter()
312 .map(|request| request.event)
313 .collect();
314 let all_valid_request_intervals = all_valid_request_intervals(&requests);
315 let retained_request_intervals =
316 retained_request_intervals(&requests, capture_limits.max_requests);
317 let mut dropped_children_due_to_request_retention =
318 DroppedChildrenDueToRequestRetention::default();
319 filter_correlated_parsed_stages(
320 &mut parsed_stages,
321 &all_valid_request_intervals,
322 &retained_request_intervals,
323 options.strict_mode(),
324 &mut warnings,
325 &mut dropped_children_due_to_request_retention,
326 )?;
327 filter_correlated_queues(
328 &mut queues,
329 &all_valid_request_intervals,
330 &retained_request_intervals,
331 options.strict_mode(),
332 &mut warnings,
333 &mut dropped_children_due_to_request_retention,
334 )?;
335 let stage_success_default_count = parsed_stages
336 .iter()
337 .take(capture_limits.max_stages)
338 .filter(|stage| stage.success_defaulted)
339 .count();
340 if stage_success_default_count > 0 {
341 warnings.push(ImportWarning::new(format!(
342 "{stage_success_default_count} stage span(s) missing optional '{TT_SUCCESS}'; assumed true"
343 )));
344 }
345 let stages: Vec<StageEvent> = parsed_stages.into_iter().map(|stage| stage.event).collect();
346 let retained_requests = &requests[..requests.len().min(capture_limits.max_requests)];
347 let retained_stages = &stages[..stages.len().min(capture_limits.max_stages)];
348 let retained_queues = &queues[..queues.len().min(capture_limits.max_queues)];
349
350 let (started_at_unix_ms, finished_at_unix_ms) =
351 retained_event_time_bounds(retained_requests, retained_stages, retained_queues)
352 .unwrap_or_else(|| {
353 let now = tailtriage_core::unix_time_ms();
354 (now, now)
355 });
356 let run_id = options.run_id_ref().map_or_else(
357 || format!("tracing-import-{started_at_unix_ms}-{finished_at_unix_ms}"),
358 ToOwned::to_owned,
359 );
360
361 let mut builder_options = RunBuilderOptions::new(options.service_name())
362 .run_id(run_id)
363 .mode(mode)
364 .capture_limits(capture_limits)
365 .strict_lifecycle(false)
366 .started_at_unix_ms(started_at_unix_ms)
367 .finished_at_unix_ms(finished_at_unix_ms)
368 .finalized_at_unix_ms(finished_at_unix_ms);
369
370 if let Some(service_version) = options.service_version_ref() {
371 builder_options = builder_options.service_version(service_version);
372 }
373
374 let mut run_builder = RunBuilder::new(builder_options).map_err(|err| match err {
375 BuildError::EmptyServiceName => ImportError::EmptyServiceName,
376 BuildError::InvalidRunTimeBounds {
377 started_at_unix_ms,
378 finished_at_unix_ms,
379 } => ImportError::InvalidField {
380 field: "tt.finished_at_unix_ms",
381 reason: format!(
382 "finished_at_unix_ms ({finished_at_unix_ms}) must be >= started_at_unix_ms ({started_at_unix_ms})"
383 ),
384 },
385 BuildError::InvalidFinalizationTime {
386 finished_at_unix_ms,
387 finalized_at_unix_ms,
388 } => ImportError::InvalidField {
389 field: "tt.finalized_at_unix_ms",
390 reason: format!(
391 "finalized_at_unix_ms ({finalized_at_unix_ms}) must be >= finished_at_unix_ms ({finished_at_unix_ms})"
392 ),
393 },
394 })?;
395
396 for request in requests {
397 run_builder
398 .push_request(request)
399 .map_err(|err| ImportError::InvalidRunEvent(err.to_string()))?;
400 }
401 for stage in stages {
402 run_builder
403 .push_stage(stage)
404 .map_err(|err| ImportError::InvalidRunEvent(err.to_string()))?;
405 }
406 for queue in queues {
407 run_builder
408 .push_queue(queue)
409 .map_err(|err| ImportError::InvalidRunEvent(err.to_string()))?;
410 }
411 let mut run = run_builder.finish();
412 run.truncation.dropped_stages = run
413 .truncation
414 .dropped_stages
415 .saturating_add(dropped_children_due_to_request_retention.stages);
416 run.truncation.dropped_queues = run
417 .truncation
418 .dropped_queues
419 .saturating_add(dropped_children_due_to_request_retention.queues);
420 if dropped_children_due_to_request_retention.stages > 0
421 || dropped_children_due_to_request_retention.queues > 0
422 {
423 run.truncation.limits_hit = true;
424 }
425 attach_durable_conversion_warnings(&mut run, &warnings);
426
427 Ok(ImportedRun::new(run, warnings))
428}
429
430#[derive(Clone, Copy)]
431struct RequestInterval {
432 started_at_unix_ms: u64,
433 finished_at_unix_ms: u64,
434}
435
436fn dedupe_retained_requests(
437 requests: &mut Vec<ParsedRequestEvent>,
438 max_requests: usize,
439 strict: bool,
440 warnings: &mut Vec<ImportWarning>,
441) -> Result<(), ImportError> {
442 let mut seen = BTreeSet::new();
443 let mut retained = Vec::with_capacity(requests.len());
444 for request in requests.drain(..) {
445 if retained.len() >= max_requests {
446 retained.push(request);
447 continue;
448 }
449 if !seen.insert(request.event.request_id.clone()) {
450 strict_or_warn(
451 strict,
452 warnings,
453 format!(
454 "duplicate tt.request_id '{}' is an input-quality problem; skipped later duplicate request event; child stage/queue evidence outside the retained first request interval may also be skipped",
455 request.event.request_id
456 ),
457 )?;
458 continue;
459 }
460 retained.push(request);
461 }
462 *requests = retained;
463 Ok(())
464}
465
466fn all_valid_request_intervals(requests: &[RequestEvent]) -> BTreeMap<String, RequestInterval> {
467 let mut intervals = BTreeMap::new();
468 for request in requests {
469 intervals
470 .entry(request.request_id.clone())
471 .or_insert(RequestInterval {
472 started_at_unix_ms: request.started_at_unix_ms,
473 finished_at_unix_ms: request.finished_at_unix_ms,
474 });
475 }
476 intervals
477}
478
479fn retained_request_intervals(
480 requests: &[RequestEvent],
481 max_requests: usize,
482) -> BTreeMap<String, RequestInterval> {
483 let mut intervals = BTreeMap::new();
484 for request in requests.iter().take(max_requests) {
485 intervals.insert(
486 request.request_id.clone(),
487 RequestInterval {
488 started_at_unix_ms: request.started_at_unix_ms,
489 finished_at_unix_ms: request.finished_at_unix_ms,
490 },
491 );
492 }
493 intervals
494}
495
496struct ParsedStageEvent {
497 event: StageEvent,
498 success_defaulted: bool,
499}
500
501struct ParsedRequestEvent {
502 event: RequestEvent,
503 outcome_defaulted: bool,
504}
505
506#[derive(Default)]
507struct DroppedChildrenDueToRequestRetention {
508 stages: u64,
509 queues: u64,
510}
511
512fn interval_within_request_with_tolerance(
513 child_start_ms: u64,
514 child_finish_ms: u64,
515 request_start_ms: u64,
516 request_finish_ms: u64,
517) -> bool {
518 child_start_ms.saturating_add(TRACE_TIME_TOLERANCE_MS) >= request_start_ms
519 && child_finish_ms <= request_finish_ms.saturating_add(TRACE_TIME_TOLERANCE_MS)
520}
521
522fn filter_correlated_parsed_stages(
523 stages: &mut Vec<ParsedStageEvent>,
524 all_valid_request_intervals: &BTreeMap<String, RequestInterval>,
525 retained_request_intervals: &BTreeMap<String, RequestInterval>,
526 strict: bool,
527 warnings: &mut Vec<ImportWarning>,
528 dropped_due_to_request_retention: &mut DroppedChildrenDueToRequestRetention,
529) -> Result<(), ImportError> {
530 let mut filtered = Vec::with_capacity(stages.len());
531 for stage in stages.drain(..) {
532 let request_id = stage.event.request_id.as_str();
533 let Some(valid_interval) = all_valid_request_intervals.get(request_id) else {
534 strict_or_warn(
535 strict,
536 warnings,
537 format!(
538 "skipped stage span for request_id '{}' because no valid matching request event was imported",
539 stage.event.request_id
540 ),
541 )?;
542 continue;
543 };
544 if !interval_within_request_with_tolerance(
545 stage.event.started_at_unix_ms,
546 stage.event.finished_at_unix_ms,
547 valid_interval.started_at_unix_ms,
548 valid_interval.finished_at_unix_ms,
549 ) {
550 strict_or_warn(
551 strict,
552 warnings,
553 format!(
554 "skipped stage span '{}' for request_id '{}' because interval [{}, {}] falls outside request interval [{}, {}] beyond tolerance_ms={TRACE_TIME_TOLERANCE_MS}",
555 stage.event.stage,
556 stage.event.request_id,
557 stage.event.started_at_unix_ms,
558 stage.event.finished_at_unix_ms,
559 valid_interval.started_at_unix_ms,
560 valid_interval.finished_at_unix_ms
561 ),
562 )?;
563 continue;
564 }
565 if !retained_request_intervals.contains_key(request_id) {
566 dropped_due_to_request_retention.stages =
567 dropped_due_to_request_retention.stages.saturating_add(1);
568 warnings.push(ImportWarning::new(format!(
569 "skipped stage span for request_id '{}' because the matching request was valid but not retained due to max_requests",
570 stage.event.request_id
571 )));
572 continue;
573 }
574 filtered.push(stage);
575 }
576 *stages = filtered;
577 Ok(())
578}
579
580fn filter_correlated_queues(
581 queues: &mut Vec<QueueEvent>,
582 all_valid_request_intervals: &BTreeMap<String, RequestInterval>,
583 retained_request_intervals: &BTreeMap<String, RequestInterval>,
584 strict: bool,
585 warnings: &mut Vec<ImportWarning>,
586 dropped_due_to_request_retention: &mut DroppedChildrenDueToRequestRetention,
587) -> Result<(), ImportError> {
588 let mut filtered = Vec::with_capacity(queues.len());
589 for queue in queues.drain(..) {
590 let request_id = queue.request_id.as_str();
591 let Some(valid_interval) = all_valid_request_intervals.get(request_id) else {
592 strict_or_warn(
593 strict,
594 warnings,
595 format!(
596 "skipped queue span for request_id '{}' because no valid matching request event was imported",
597 queue.request_id
598 ),
599 )?;
600 continue;
601 };
602 if !interval_within_request_with_tolerance(
603 queue.waited_from_unix_ms,
604 queue.waited_until_unix_ms,
605 valid_interval.started_at_unix_ms,
606 valid_interval.finished_at_unix_ms,
607 ) {
608 strict_or_warn(
609 strict,
610 warnings,
611 format!(
612 "skipped queue span '{}' for request_id '{}' because interval [{}, {}] falls outside request interval [{}, {}] beyond tolerance_ms={TRACE_TIME_TOLERANCE_MS}",
613 queue.queue,
614 queue.request_id,
615 queue.waited_from_unix_ms,
616 queue.waited_until_unix_ms,
617 valid_interval.started_at_unix_ms,
618 valid_interval.finished_at_unix_ms
619 ),
620 )?;
621 continue;
622 }
623 if !retained_request_intervals.contains_key(request_id) {
624 dropped_due_to_request_retention.queues =
625 dropped_due_to_request_retention.queues.saturating_add(1);
626 warnings.push(ImportWarning::new(format!(
627 "skipped queue span for request_id '{}' because the matching request was valid but not retained due to max_requests",
628 queue.request_id
629 )));
630 continue;
631 }
632 filtered.push(queue);
633 }
634 *queues = filtered;
635 Ok(())
636}
637
638fn validate_service_name(service_name: &str) -> Result<(), ImportError> {
639 if service_name.trim().is_empty() {
640 return Err(ImportError::EmptyServiceName);
641 }
642 Ok(())
643}
644
645fn retained_event_time_bounds(
646 requests: &[RequestEvent],
647 stages: &[StageEvent],
648 queues: &[QueueEvent],
649) -> Option<(u64, u64)> {
650 let request_bounds = requests
651 .iter()
652 .map(|request| (request.started_at_unix_ms, request.finished_at_unix_ms));
653 let stage_bounds = stages
654 .iter()
655 .map(|stage| (stage.started_at_unix_ms, stage.finished_at_unix_ms));
656 let queue_bounds = queues
657 .iter()
658 .map(|queue| (queue.waited_from_unix_ms, queue.waited_until_unix_ms));
659 request_bounds.chain(stage_bounds).chain(queue_bounds).fold(
660 None,
661 |acc: Option<(u64, u64)>, (start, finish)| {
662 Some(match acc {
663 Some((min_start, max_finish)) => (min_start.min(start), max_finish.max(finish)),
664 None => (start, finish),
665 })
666 },
667 )
668}
669
670enum StringFieldState<'a> {
671 Missing,
672 Value(&'a str),
673 InvalidType,
674}
675
676enum OptionalField<T> {
677 Missing,
678 Value(T),
679 Invalid,
680}
681
682fn get_string_field_state<'a>(span: &'a SpanRecord, key: &str) -> StringFieldState<'a> {
683 match span.fields().get(key) {
684 Some(FieldValue::String(value)) => StringFieldState::Value(value.as_str()),
685 Some(_) => StringFieldState::InvalidType,
686 None => StringFieldState::Missing,
687 }
688}
689
690fn span_has_tailtriage_field(span: &SpanRecord) -> bool {
691 span.fields().keys().any(|key| key.starts_with("tt."))
692}
693
694fn required_string(
695 span: &SpanRecord,
696 key: &'static str,
697 strict: bool,
698 warnings: &mut Vec<ImportWarning>,
699) -> Result<Option<String>, ImportError> {
700 match get_string_field_state(span, key) {
701 StringFieldState::Value(value) => {
702 if value.trim().is_empty() {
703 strict_or_warn(
704 strict,
705 warnings,
706 format!(
707 "invalid field '{key}' in span '{}': required string cannot be empty or whitespace",
708 span.name()
709 ),
710 )?;
711 Ok(None)
712 } else {
713 Ok(Some(value.to_owned()))
714 }
715 }
716 StringFieldState::Missing => {
717 strict_or_warn(
718 strict,
719 warnings,
720 format!("missing required field '{key}' in span '{}'", span.name()),
721 )?;
722 Ok(None)
723 }
724 StringFieldState::InvalidType => {
725 strict_or_warn(
726 strict,
727 warnings,
728 format!(
729 "invalid field '{key}' in span '{}': expected string",
730 span.name()
731 ),
732 )?;
733 Ok(None)
734 }
735 }
736}
737
738pub(crate) const TRACE_TIME_TOLERANCE_US: u64 = 2_000;
739pub(crate) const TRACE_TIME_TOLERANCE_MS: u64 = TRACE_TIME_TOLERANCE_US / 1_000;
740
741pub(crate) fn duration_within_derived_tolerance(duration_us: u64, derived_us: u64) -> bool {
742 duration_us.abs_diff(derived_us) <= TRACE_TIME_TOLERANCE_US
743}
744
745#[cfg(feature = "live")]
746pub(crate) fn duration_within_tolerance(
747 duration_us: u64,
748 started_at_unix_ms: u64,
749 finished_at_unix_ms: u64,
750) -> bool {
751 let derived_us = timestamp_derived_duration_us(started_at_unix_ms, finished_at_unix_ms);
752 duration_within_derived_tolerance(duration_us, derived_us)
753}
754
755fn timestamp_derived_duration_us(started_at_unix_ms: u64, finished_at_unix_ms: u64) -> u64 {
756 finished_at_unix_ms
757 .saturating_sub(started_at_unix_ms)
758 .saturating_mul(1000)
759}
760
761fn sanitized_run_relative_offsets(
762 span: &SpanRecord,
763 strict: bool,
764 warnings: &mut Vec<ImportWarning>,
765) -> Result<(Option<u64>, Option<u64>), ImportError> {
766 match (span.started_at_run_us_ref(), span.finished_at_run_us_ref()) {
767 (Some(started_at_run_us), Some(finished_at_run_us))
768 if finished_at_run_us >= started_at_run_us =>
769 {
770 Ok((Some(started_at_run_us), Some(finished_at_run_us)))
771 }
772 (Some(started_at_run_us), Some(finished_at_run_us)) => {
773 let message = format!(
774 "span '{}' run-relative timing is inverted: start={} finish={}; dropped run-relative offsets",
775 span.name(),
776 started_at_run_us,
777 finished_at_run_us
778 );
779 if strict {
780 return Err(ImportError::StrictViolation(message));
781 }
782 warnings.push(ImportWarning::new(message));
783 Ok((None, None))
784 }
785 (Some(offset), None) => {
786 let message = format!(
787 "span '{}' incomplete run-relative timing: started_at_run_us={} finished_at_run_us missing; dropped run-relative offsets",
788 span.name(),
789 offset
790 );
791 if strict {
792 return Err(ImportError::StrictViolation(message));
793 }
794 warnings.push(ImportWarning::new(message));
795 Ok((None, None))
796 }
797 (None, Some(offset)) => {
798 let message = format!(
799 "span '{}' incomplete run-relative timing: started_at_run_us missing finished_at_run_us={}; dropped run-relative offsets",
800 span.name(),
801 offset
802 );
803 if strict {
804 return Err(ImportError::StrictViolation(message));
805 }
806 warnings.push(ImportWarning::new(message));
807 Ok((None, None))
808 }
809 (None, None) => Ok((None, None)),
810 }
811}
812
813fn run_relative_derived_duration_us(
814 started_at_run_us: Option<u64>,
815 finished_at_run_us: Option<u64>,
816) -> Option<u64> {
817 Some(finished_at_run_us?.saturating_sub(started_at_run_us?))
818}
819
820fn elapsed_duration_us(
821 span: &SpanRecord,
822 started_at_run_us: Option<u64>,
823 finished_at_run_us: Option<u64>,
824 strict: bool,
825 warnings: &mut Vec<ImportWarning>,
826) -> Result<u64, ImportError> {
827 let unix_derived_us =
828 timestamp_derived_duration_us(span.started_at_unix_ms(), span.finished_at_unix_ms());
829 let run_relative_derived_us =
830 run_relative_derived_duration_us(started_at_run_us, finished_at_run_us);
831
832 let Some(duration_us) = span.duration_us_ref() else {
833 return Ok(run_relative_derived_us.unwrap_or(unix_derived_us));
834 };
835
836 if let Some(run_relative_derived_us) = run_relative_derived_us {
837 if duration_within_derived_tolerance(duration_us, run_relative_derived_us) {
838 return Ok(duration_us);
839 }
840
841 if strict {
842 return Err(ImportError::StrictViolation(format!(
843 "span '{}' duration_us differs from run-relative duration beyond tolerance: duration_us={} run_relative_duration_us={} tolerance_us={TRACE_TIME_TOLERANCE_US}; strict import rejected the mismatch; Unix timestamps remain wall-clock anchors",
844 span.name(),
845 duration_us,
846 run_relative_derived_us,
847 )));
848 }
849
850 warnings.push(ImportWarning::new(format!(
851 "span '{}' duration_us differs from run-relative duration beyond tolerance: duration_us={} run_relative_duration_us={} tolerance_us={TRACE_TIME_TOLERANCE_US}; duration_us was retained as authoritative elapsed-time evidence; Unix timestamps remain wall-clock anchors",
852 span.name(),
853 duration_us,
854 run_relative_derived_us,
855 )));
856 return Ok(duration_us);
857 }
858
859 if duration_within_derived_tolerance(duration_us, unix_derived_us) {
860 return Ok(duration_us);
861 }
862
863 if strict {
864 return Err(ImportError::StrictViolation(format!(
865 "span '{}' duration_us differs from timestamp-derived duration beyond tolerance: duration_us={} timestamp_derived_duration_us={} tolerance_us={TRACE_TIME_TOLERANCE_US}; strict import rejected the mismatch; Unix timestamps remain wall-clock anchors",
866 span.name(),
867 duration_us,
868 unix_derived_us
869 )));
870 }
871
872 warnings.push(ImportWarning::new(format!(
873 "span '{}' duration_us differs from timestamp-derived duration beyond tolerance: duration_us={} timestamp_derived_duration_us={} tolerance_us={TRACE_TIME_TOLERANCE_US}; duration_us was retained as authoritative elapsed-time evidence; Unix timestamps remain wall-clock anchors",
874 span.name(),
875 duration_us,
876 unix_derived_us
877 )));
878 Ok(duration_us)
879}
880
881fn is_durable_conversion_warning(message: &str) -> bool {
882 message.starts_with("skipped ")
883 || message.starts_with("duplicate tt.request_id")
884 || message.starts_with("missing required field")
885 || message.starts_with("invalid field")
886 || message.starts_with("unknown tt.kind")
887 || message.contains("duration_us differs from timestamp-derived duration")
888 || message.contains("duration_us differs from run-relative duration")
889 || message.contains("run-relative timing is inverted")
890 || message.contains("incomplete run-relative timing")
891 || message.contains("missing optional 'tt.outcome'; assumed 'ok'")
892 || message.contains("missing optional 'tt.success'; assumed true")
893}
894
895fn attach_durable_conversion_warnings(run: &mut tailtriage_core::Run, warnings: &[ImportWarning]) {
896 for warning in warnings {
897 let message = warning.message();
898 if is_durable_conversion_warning(message)
899 && !run
900 .metadata
901 .lifecycle_warnings
902 .iter()
903 .any(|existing| existing == message)
904 {
905 run.metadata.lifecycle_warnings.push(message.to_owned());
906 }
907 }
908}
909
910#[cfg(test)]
911mod persistable_tests {
912 use super::ensure_persistable_run_has_requests;
913 use crate::ImportError;
914 use tailtriage_core::{MemorySink, RequestEvent, Tailtriage};
915
916 #[test]
917 fn ensure_persistable_run_has_requests_accepts_non_empty_runs() {
918 let collector = Tailtriage::builder("svc")
919 .sink(MemorySink::new())
920 .build()
921 .unwrap();
922 let mut run = collector.snapshot();
923 run.requests.push(RequestEvent {
924 request_id: "r1".into(),
925 route: "/".into(),
926 kind: None,
927 started_at_unix_ms: 1,
928 started_at_run_us: None,
929 finished_at_unix_ms: 2,
930 finished_at_run_us: None,
931 latency_us: 1_000,
932 outcome: "ok".into(),
933 });
934 assert!(ensure_persistable_run_has_requests(&run).is_ok());
935 }
936
937 #[test]
938 fn ensure_persistable_run_has_requests_rejects_empty_runs() {
939 let run = Tailtriage::builder("svc")
940 .sink(MemorySink::new())
941 .build()
942 .unwrap()
943 .snapshot();
944 let err = ensure_persistable_run_has_requests(&run).unwrap_err();
945 assert!(matches!(err, ImportError::ZeroRequestArtifact { .. }));
946 }
947}
948
949fn strict_or_warn(
950 strict: bool,
951 warnings: &mut Vec<ImportWarning>,
952 message: String,
953) -> Result<(), ImportError> {
954 if strict {
955 return Err(ImportError::StrictViolation(message));
956 }
957 warnings.push(ImportWarning::new(message));
958 Ok(())
959}
960
961#[cfg(test)]
962const RECOMMENDED_OUTCOME_LABELS: [&str; 5] = ["ok", "error", "timeout", "cancelled", "rejected"];
963
964fn parse_outcome(
965 span: &SpanRecord,
966 strict: bool,
967 warnings: &mut Vec<ImportWarning>,
968) -> Result<Option<(String, bool)>, ImportError> {
969 match get_string_field_state(span, TT_OUTCOME) {
970 StringFieldState::Missing => Ok(Some(("ok".to_owned(), true))),
971 StringFieldState::Value(value) => {
972 if value.trim().is_empty() {
973 strict_or_warn(
974 strict,
975 warnings,
976 format!(
977 "invalid field '{TT_OUTCOME}' in span '{}': expected non-empty, non-whitespace string",
978 span.name()
979 ),
980 )?;
981 Ok(None)
982 } else {
983 Ok(Some((value.to_owned(), false)))
984 }
985 }
986 StringFieldState::InvalidType => {
987 strict_or_warn(
988 strict,
989 warnings,
990 format!(
991 "invalid field '{TT_OUTCOME}' in span '{}': expected string",
992 span.name()
993 ),
994 )?;
995 Ok(None)
996 }
997 }
998}
999
1000fn parse_success(
1001 span: &SpanRecord,
1002 strict: bool,
1003 warnings: &mut Vec<ImportWarning>,
1004) -> Result<OptionalField<bool>, ImportError> {
1005 match span.fields().get(TT_SUCCESS) {
1006 Some(FieldValue::Bool(value)) => Ok(OptionalField::Value(*value)),
1007 Some(FieldValue::String(value)) if value.eq_ignore_ascii_case("true") => {
1008 Ok(OptionalField::Value(true))
1009 }
1010 Some(FieldValue::String(value)) if value.eq_ignore_ascii_case("false") => {
1011 Ok(OptionalField::Value(false))
1012 }
1013 Some(_) => {
1014 strict_or_warn(strict, warnings, format!("invalid field '{TT_SUCCESS}' in span '{}': expected bool or 'true'/'false' string", span.name()))?;
1015 Ok(OptionalField::Invalid)
1016 }
1017 None => Ok(OptionalField::Missing),
1018 }
1019}
1020
1021fn parse_depth_at_start(
1022 span: &SpanRecord,
1023 strict: bool,
1024 warnings: &mut Vec<ImportWarning>,
1025) -> Result<OptionalField<u64>, ImportError> {
1026 match span.fields().get(TT_DEPTH_AT_START) {
1027 Some(FieldValue::U64(value)) => Ok(OptionalField::Value(*value)),
1028 Some(FieldValue::I64(value)) if *value >= 0 => {
1029 if let Ok(parsed) = u64::try_from(*value) {
1030 Ok(OptionalField::Value(parsed))
1031 } else {
1032 strict_or_warn(
1033 strict,
1034 warnings,
1035 format!(
1036 "invalid field '{TT_DEPTH_AT_START}' in span '{}': expected non-negative integer",
1037 span.name()
1038 ),
1039 )?;
1040 Ok(OptionalField::Invalid)
1041 }
1042 }
1043 Some(_) => {
1044 strict_or_warn(strict, warnings, format!("invalid field '{TT_DEPTH_AT_START}' in span '{}': expected non-negative integer", span.name()))?;
1045 Ok(OptionalField::Invalid)
1046 }
1047 None => Ok(OptionalField::Missing),
1048 }
1049}
1050
1051#[cfg(test)]
1052mod tests {
1053 use super::*;
1054 use tailtriage_core::CaptureMode;
1055
1056 #[test]
1057 fn span_kind_parser_accepts_supported_values_only() {
1058 assert_eq!(SpanKind::parse("request"), Some(SpanKind::Request));
1059 assert_eq!(SpanKind::parse("stage"), Some(SpanKind::Stage));
1060 assert_eq!(SpanKind::parse("queue"), Some(SpanKind::Queue));
1061 assert_eq!(SpanKind::parse("Request"), None);
1062 assert_eq!(SpanKind::parse("wat"), None);
1063 }
1064
1065 #[test]
1066 fn request_only_conversion_creates_one_request_event() {
1067 let spans = vec![SpanRecord::new("req", 100, 110)
1068 .field(TT_KIND, "request")
1069 .field(TT_REQUEST_ID, "r1")
1070 .field(TT_ROUTE, "/a")];
1071 let imported = run_from_span_records(spans, ImportOptions::new("svc")).expect("ok");
1072 assert_eq!(imported.run().requests.len(), 1);
1073 }
1074
1075 #[test]
1076 fn request_and_stage_convert() {
1077 let spans = vec![
1078 SpanRecord::new("req", 100, 120)
1079 .field(TT_KIND, "request")
1080 .field(TT_REQUEST_ID, "r1")
1081 .field(TT_ROUTE, "/a"),
1082 SpanRecord::new("st", 105, 115)
1083 .field(TT_KIND, "stage")
1084 .field(TT_REQUEST_ID, "r1")
1085 .field(TT_STAGE, "db"),
1086 ];
1087 let run = run_from_span_records(spans, ImportOptions::new("svc"))
1088 .unwrap()
1089 .run()
1090 .clone();
1091 assert_eq!(run.requests.len(), 1);
1092 assert_eq!(run.stages.len(), 1);
1093 }
1094
1095 #[test]
1096 fn request_and_queue_convert() {
1097 let spans = vec![
1098 SpanRecord::new("req", 100, 120)
1099 .field(TT_KIND, "request")
1100 .field(TT_REQUEST_ID, "r1")
1101 .field(TT_ROUTE, "/a"),
1102 SpanRecord::new("q", 102, 103)
1103 .field(TT_KIND, "queue")
1104 .field(TT_REQUEST_ID, "r1")
1105 .field(TT_QUEUE, "permits"),
1106 ];
1107 let run = run_from_span_records(spans, ImportOptions::new("svc"))
1108 .unwrap()
1109 .run()
1110 .clone();
1111 assert_eq!(run.queues.len(), 1);
1112 }
1113
1114 #[test]
1115 fn span_record_run_relative_fields_convert_to_core_events() {
1116 let spans = vec![
1117 SpanRecord::new("req", 100, 120)
1118 .started_at_run_us(10)
1119 .finished_at_run_us(20_010)
1120 .duration_us(20_000)
1121 .field(TT_KIND, "request")
1122 .field(TT_REQUEST_ID, "r1")
1123 .field(TT_ROUTE, "/a"),
1124 SpanRecord::new("st", 105, 115)
1125 .started_at_run_us(5_010)
1126 .finished_at_run_us(15_010)
1127 .duration_us(10_000)
1128 .field(TT_KIND, "stage")
1129 .field(TT_REQUEST_ID, "r1")
1130 .field(TT_STAGE, "db"),
1131 SpanRecord::new("q", 102, 103)
1132 .started_at_run_us(2_010)
1133 .finished_at_run_us(3_010)
1134 .duration_us(1_000)
1135 .field(TT_KIND, "queue")
1136 .field(TT_REQUEST_ID, "r1")
1137 .field(TT_QUEUE, "permits"),
1138 ];
1139 let run = run_from_span_records(spans, ImportOptions::new("svc"))
1140 .unwrap()
1141 .run()
1142 .clone();
1143
1144 assert_eq!(run.requests[0].started_at_run_us, Some(10));
1145 assert_eq!(run.requests[0].finished_at_run_us, Some(20_010));
1146 assert_eq!(run.stages[0].started_at_run_us, Some(5_010));
1147 assert_eq!(run.stages[0].finished_at_run_us, Some(15_010));
1148 assert_eq!(run.queues[0].waited_from_run_us, Some(2_010));
1149 assert_eq!(run.queues[0].waited_until_run_us, Some(3_010));
1150 }
1151
1152 #[test]
1153 fn missing_duration_uses_run_relative_delta_before_unix_bounds() {
1154 let spans = vec![SpanRecord::new("req", 10, 11)
1155 .started_at_run_us(1_000)
1156 .finished_at_run_us(51_000)
1157 .field(TT_KIND, "request")
1158 .field(TT_REQUEST_ID, "r1")
1159 .field(TT_ROUTE, "/a")];
1160
1161 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1162
1163 assert_eq!(imported.run().requests[0].latency_us, 50_000);
1164 }
1165
1166 #[test]
1167 fn strict_duration_matching_run_relative_allows_wall_clock_mismatch() {
1168 let spans = vec![SpanRecord::new("req", 10, 11)
1169 .started_at_run_us(1_000)
1170 .finished_at_run_us(51_000)
1171 .duration_us(50_000)
1172 .field(TT_KIND, "request")
1173 .field(TT_REQUEST_ID, "r1")
1174 .field(TT_ROUTE, "/a")];
1175
1176 let imported =
1177 run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap();
1178
1179 assert_eq!(imported.run().requests[0].latency_us, 50_000);
1180 }
1181
1182 #[test]
1183 fn strict_duration_mismatching_run_relative_fails_even_if_unix_matches() {
1184 let spans = vec![SpanRecord::new("req", 10, 60)
1185 .started_at_run_us(1_000)
1186 .finished_at_run_us(11_000)
1187 .duration_us(50_000)
1188 .field(TT_KIND, "request")
1189 .field(TT_REQUEST_ID, "r1")
1190 .field(TT_ROUTE, "/a")];
1191
1192 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true))
1193 .expect_err("strict import should reject duration/run-relative mismatch");
1194
1195 let message = err.to_string();
1196 assert!(message.contains("duration_us differs from run-relative duration"));
1197 assert!(message.contains("strict import rejected the mismatch"));
1198 assert!(!message.contains("duration_us was retained"));
1199 }
1200
1201 #[test]
1202 fn non_strict_duration_mismatching_run_relative_warns_and_retains_duration() {
1203 let spans = vec![SpanRecord::new("req", 10, 60)
1204 .started_at_run_us(1_000)
1205 .finished_at_run_us(11_000)
1206 .duration_us(50_000)
1207 .field(TT_KIND, "request")
1208 .field(TT_REQUEST_ID, "r1")
1209 .field(TT_ROUTE, "/a")];
1210
1211 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1212
1213 assert_eq!(imported.run().requests[0].latency_us, 50_000);
1214 assert!(imported.warnings().iter().any(|w| w
1215 .message()
1216 .contains("duration_us differs from run-relative duration")));
1217 assert!(imported
1218 .run()
1219 .metadata
1220 .lifecycle_warnings
1221 .iter()
1222 .any(|w| w.contains("duration_us differs from run-relative duration")));
1223 }
1224
1225 #[test]
1226 fn non_strict_inverted_request_run_relative_offsets_are_dropped_with_warning() {
1227 let spans = vec![SpanRecord::new("req", 100, 120)
1228 .started_at_run_us(20_000)
1229 .finished_at_run_us(10_000)
1230 .field(TT_KIND, "request")
1231 .field(TT_REQUEST_ID, "r1")
1232 .field(TT_ROUTE, "/a")];
1233
1234 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1235
1236 assert_eq!(imported.run().requests.len(), 1);
1237 assert_eq!(imported.run().requests[0].started_at_run_us, None);
1238 assert_eq!(imported.run().requests[0].finished_at_run_us, None);
1239 assert!(imported
1240 .warnings()
1241 .iter()
1242 .any(|w| w.message().contains("run-relative timing is inverted")));
1243 assert!(imported
1244 .warnings()
1245 .iter()
1246 .any(|w| w.message().contains("dropped run-relative offsets")));
1247 }
1248
1249 #[test]
1250 fn strict_inverted_request_run_relative_offsets_fail() {
1251 let spans = vec![SpanRecord::new("req", 100, 120)
1252 .started_at_run_us(20_000)
1253 .finished_at_run_us(10_000)
1254 .field(TT_KIND, "request")
1255 .field(TT_REQUEST_ID, "r1")
1256 .field(TT_ROUTE, "/a")];
1257
1258 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true))
1259 .expect_err("strict import should reject inverted run-relative offsets");
1260
1261 assert!(matches!(err, ImportError::StrictViolation(_)));
1262 assert!(err.to_string().contains("run-relative timing is inverted"));
1263 }
1264
1265 #[test]
1266 fn non_strict_incomplete_request_run_relative_offsets_are_dropped_with_warning() {
1267 let spans = vec![SpanRecord::new("req", 100, 120)
1268 .started_at_run_us(10_000)
1269 .field(TT_KIND, "request")
1270 .field(TT_REQUEST_ID, "r1")
1271 .field(TT_ROUTE, "/a")];
1272
1273 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1274
1275 assert_eq!(imported.run().requests.len(), 1);
1276 assert_eq!(imported.run().requests[0].started_at_run_us, None);
1277 assert_eq!(imported.run().requests[0].finished_at_run_us, None);
1278 assert!(imported
1279 .warnings()
1280 .iter()
1281 .any(|w| w.message().contains("incomplete run-relative timing")));
1282 assert!(imported
1283 .warnings()
1284 .iter()
1285 .any(|w| w.message().contains("dropped run-relative offsets")));
1286 }
1287
1288 #[test]
1289 fn non_strict_inverted_queue_run_relative_offsets_are_dropped_with_warning() {
1290 let spans = vec![
1291 SpanRecord::new("req", 100, 120)
1292 .field(TT_KIND, "request")
1293 .field(TT_REQUEST_ID, "r1")
1294 .field(TT_ROUTE, "/a"),
1295 SpanRecord::new("q", 102, 103)
1296 .started_at_run_us(3_000)
1297 .finished_at_run_us(2_000)
1298 .field(TT_KIND, "queue")
1299 .field(TT_REQUEST_ID, "r1")
1300 .field(TT_QUEUE, "permits"),
1301 ];
1302
1303 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1304
1305 assert_eq!(imported.run().queues.len(), 1);
1306 assert_eq!(imported.run().queues[0].waited_from_run_us, None);
1307 assert_eq!(imported.run().queues[0].waited_until_run_us, None);
1308 assert!(imported
1309 .warnings()
1310 .iter()
1311 .any(|w| w.message().contains("run-relative timing is inverted")));
1312 }
1313
1314 #[test]
1315 fn strict_inverted_queue_run_relative_offsets_fail() {
1316 let spans = vec![
1317 SpanRecord::new("req", 100, 120)
1318 .field(TT_KIND, "request")
1319 .field(TT_REQUEST_ID, "r1")
1320 .field(TT_ROUTE, "/a"),
1321 SpanRecord::new("q", 102, 103)
1322 .started_at_run_us(3_000)
1323 .finished_at_run_us(2_000)
1324 .field(TT_KIND, "queue")
1325 .field(TT_REQUEST_ID, "r1")
1326 .field(TT_QUEUE, "permits"),
1327 ];
1328
1329 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true))
1330 .expect_err("strict import should reject inverted queue run-relative offsets");
1331
1332 assert!(matches!(err, ImportError::StrictViolation(_)));
1333 assert!(err.to_string().contains("run-relative timing is inverted"));
1334 }
1335
1336 #[test]
1337 fn non_strict_incomplete_queue_run_relative_offsets_are_dropped_with_warning() {
1338 let spans = vec![
1339 SpanRecord::new("req", 100, 120)
1340 .field(TT_KIND, "request")
1341 .field(TT_REQUEST_ID, "r1")
1342 .field(TT_ROUTE, "/a"),
1343 SpanRecord::new("q", 102, 103)
1344 .finished_at_run_us(3_000)
1345 .field(TT_KIND, "queue")
1346 .field(TT_REQUEST_ID, "r1")
1347 .field(TT_QUEUE, "permits"),
1348 ];
1349
1350 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1351
1352 assert_eq!(imported.run().queues.len(), 1);
1353 assert_eq!(imported.run().queues[0].waited_from_run_us, None);
1354 assert_eq!(imported.run().queues[0].waited_until_run_us, None);
1355 assert!(imported
1356 .warnings()
1357 .iter()
1358 .any(|w| w.message().contains("incomplete run-relative timing")));
1359 assert!(imported
1360 .warnings()
1361 .iter()
1362 .any(|w| w.message().contains("dropped run-relative offsets")));
1363 }
1364
1365 #[test]
1366 fn strict_incomplete_queue_run_relative_offsets_fail() {
1367 let spans = vec![
1368 SpanRecord::new("req", 100, 120)
1369 .field(TT_KIND, "request")
1370 .field(TT_REQUEST_ID, "r1")
1371 .field(TT_ROUTE, "/a"),
1372 SpanRecord::new("q", 102, 103)
1373 .finished_at_run_us(3_000)
1374 .field(TT_KIND, "queue")
1375 .field(TT_REQUEST_ID, "r1")
1376 .field(TT_QUEUE, "permits"),
1377 ];
1378
1379 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true))
1380 .expect_err("strict import should reject incomplete run-relative offsets");
1381
1382 assert!(matches!(err, ImportError::StrictViolation(_)));
1383 assert!(err.to_string().contains("incomplete run-relative timing"));
1384 }
1385
1386 #[test]
1387 fn non_strict_orphan_stage_is_skipped_and_warning_is_durable() {
1388 let spans = vec![
1389 SpanRecord::new("req", 100, 120)
1390 .field(TT_KIND, "request")
1391 .field(TT_REQUEST_ID, "r1")
1392 .field(TT_ROUTE, "/a"),
1393 SpanRecord::new("st", 102, 119)
1394 .field(TT_KIND, "stage")
1395 .field(TT_REQUEST_ID, "r-orphan")
1396 .field(TT_STAGE, "db"),
1397 ];
1398 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1399 assert_eq!(imported.run().requests.len(), 1);
1400 assert_eq!(imported.run().stages.len(), 0);
1401 let warning = "skipped stage span for request_id 'r-orphan' because no valid matching request event was imported";
1402 assert!(imported
1403 .warnings()
1404 .iter()
1405 .any(|w| w.message().contains(warning)));
1406 assert!(imported
1407 .run()
1408 .metadata
1409 .lifecycle_warnings
1410 .iter()
1411 .any(|w| w.contains(warning)));
1412 }
1413
1414 #[test]
1415 fn orphan_stage_does_not_affect_retained_bounds_or_default_stage_success_warning() {
1416 let spans = vec![
1417 SpanRecord::new("req", 100, 120)
1418 .field(TT_KIND, "request")
1419 .field(TT_REQUEST_ID, "r1")
1420 .field(TT_ROUTE, "/a"),
1421 SpanRecord::new("st", 1, 1_000_000)
1422 .field(TT_KIND, "stage")
1423 .field(TT_REQUEST_ID, "r-orphan")
1424 .field(TT_STAGE, "db"),
1425 ];
1426 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1427 let run = imported.run();
1428 assert_eq!(run.requests.len(), 1);
1429 assert_eq!(run.stages.len(), 0);
1430 assert_eq!(run.metadata.started_at_unix_ms, 100);
1431 assert_eq!(run.metadata.finished_at_unix_ms, 120);
1432 assert!(run.metadata.run_id.contains("tracing-import-100-120"));
1433 assert!(imported.warnings().iter().any(|w| w
1434 .message()
1435 .contains("skipped stage span for request_id 'r-orphan'")));
1436 assert!(imported.warnings().iter().all(|w| !w
1437 .message()
1438 .contains("missing optional 'tt.success'; assumed true")));
1439 assert!(run
1440 .metadata
1441 .lifecycle_warnings
1442 .iter()
1443 .all(|w| !w.contains("missing optional 'tt.success'; assumed true")));
1444 }
1445
1446 #[test]
1447 fn strict_orphan_stage_fails() {
1448 let spans = vec![
1449 SpanRecord::new("req", 100, 120)
1450 .field(TT_KIND, "request")
1451 .field(TT_REQUEST_ID, "r1")
1452 .field(TT_ROUTE, "/a"),
1453 SpanRecord::new("st", 102, 119)
1454 .field(TT_KIND, "stage")
1455 .field(TT_REQUEST_ID, "r-orphan")
1456 .field(TT_STAGE, "db"),
1457 ];
1458 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
1459 match err {
1460 ImportError::StrictViolation(message) => {
1461 assert!(message.contains("no valid matching request event"));
1462 }
1463 _ => panic!("expected StrictViolation"),
1464 }
1465 }
1466
1467 #[test]
1468 fn non_strict_orphan_queue_is_skipped_and_warning_is_durable() {
1469 let spans = vec![
1470 SpanRecord::new("req", 100, 120)
1471 .field(TT_KIND, "request")
1472 .field(TT_REQUEST_ID, "r1")
1473 .field(TT_ROUTE, "/a"),
1474 SpanRecord::new("q", 102, 119)
1475 .field(TT_KIND, "queue")
1476 .field(TT_REQUEST_ID, "r-orphan")
1477 .field(TT_QUEUE, "permits"),
1478 ];
1479 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1480 assert_eq!(imported.run().requests.len(), 1);
1481 assert_eq!(imported.run().queues.len(), 0);
1482 let warning = "skipped queue span for request_id 'r-orphan' because no valid matching request event was imported";
1483 assert!(imported
1484 .warnings()
1485 .iter()
1486 .any(|w| w.message().contains(warning)));
1487 assert!(imported
1488 .run()
1489 .metadata
1490 .lifecycle_warnings
1491 .iter()
1492 .any(|w| w.contains(warning)));
1493 }
1494
1495 #[test]
1496 fn strict_orphan_queue_fails() {
1497 let spans = vec![
1498 SpanRecord::new("req", 100, 120)
1499 .field(TT_KIND, "request")
1500 .field(TT_REQUEST_ID, "r1")
1501 .field(TT_ROUTE, "/a"),
1502 SpanRecord::new("q", 102, 119)
1503 .field(TT_KIND, "queue")
1504 .field(TT_REQUEST_ID, "r-orphan")
1505 .field(TT_QUEUE, "permits"),
1506 ];
1507 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
1508 match err {
1509 ImportError::StrictViolation(message) => {
1510 assert!(message.contains("no valid matching request event"));
1511 }
1512 _ => panic!("expected StrictViolation"),
1513 }
1514 }
1515
1516 #[test]
1517 fn non_strict_stage_before_request_start_is_skipped_and_warning_is_durable() {
1518 let spans = vec![
1519 SpanRecord::new("req", 100, 120)
1520 .field(TT_KIND, "request")
1521 .field(TT_REQUEST_ID, "r1")
1522 .field(TT_ROUTE, "/a"),
1523 SpanRecord::new("stage", 97, 110)
1524 .field(TT_KIND, "stage")
1525 .field(TT_REQUEST_ID, "r1")
1526 .field(TT_STAGE, "db"),
1527 ];
1528 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1529 assert!(imported.run().stages.is_empty());
1530 let warning = "skipped stage span 'db' for request_id 'r1' because interval [97, 110] falls outside request interval [100, 120] beyond tolerance_ms=2";
1531 assert!(imported
1532 .warnings()
1533 .iter()
1534 .any(|w| w.message().contains(warning)));
1535 assert!(imported
1536 .run()
1537 .metadata
1538 .lifecycle_warnings
1539 .iter()
1540 .any(|w| w.contains(warning)));
1541 }
1542
1543 #[test]
1544 fn non_strict_stage_after_request_finish_is_skipped_and_warning_is_durable() {
1545 let spans = vec![
1546 SpanRecord::new("req", 100, 120)
1547 .field(TT_KIND, "request")
1548 .field(TT_REQUEST_ID, "r1")
1549 .field(TT_ROUTE, "/a"),
1550 SpanRecord::new("stage", 110, 123)
1551 .field(TT_KIND, "stage")
1552 .field(TT_REQUEST_ID, "r1")
1553 .field(TT_STAGE, "db"),
1554 ];
1555 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1556 assert!(imported.run().stages.is_empty());
1557 let warning = "skipped stage span 'db' for request_id 'r1' because interval [110, 123] falls outside request interval [100, 120] beyond tolerance_ms=2";
1558 assert!(imported
1559 .warnings()
1560 .iter()
1561 .any(|w| w.message().contains(warning)));
1562 assert!(imported
1563 .run()
1564 .metadata
1565 .lifecycle_warnings
1566 .iter()
1567 .any(|w| w.contains(warning)));
1568 }
1569
1570 #[test]
1571 fn non_strict_queue_before_request_start_is_skipped_and_warning_is_durable() {
1572 let spans = vec![
1573 SpanRecord::new("req", 100, 120)
1574 .field(TT_KIND, "request")
1575 .field(TT_REQUEST_ID, "r1")
1576 .field(TT_ROUTE, "/a"),
1577 SpanRecord::new("queue", 97, 110)
1578 .field(TT_KIND, "queue")
1579 .field(TT_REQUEST_ID, "r1")
1580 .field(TT_QUEUE, "permits"),
1581 ];
1582 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1583 assert!(imported.run().queues.is_empty());
1584 let warning = "skipped queue span 'permits' for request_id 'r1' because interval [97, 110] falls outside request interval [100, 120] beyond tolerance_ms=2";
1585 assert!(imported
1586 .warnings()
1587 .iter()
1588 .any(|w| w.message().contains(warning)));
1589 assert!(imported
1590 .run()
1591 .metadata
1592 .lifecycle_warnings
1593 .iter()
1594 .any(|w| w.contains(warning)));
1595 }
1596
1597 #[test]
1598 fn non_strict_queue_after_request_finish_is_skipped_and_warning_is_durable() {
1599 let spans = vec![
1600 SpanRecord::new("req", 100, 120)
1601 .field(TT_KIND, "request")
1602 .field(TT_REQUEST_ID, "r1")
1603 .field(TT_ROUTE, "/a"),
1604 SpanRecord::new("queue", 110, 123)
1605 .field(TT_KIND, "queue")
1606 .field(TT_REQUEST_ID, "r1")
1607 .field(TT_QUEUE, "permits"),
1608 ];
1609 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1610 assert!(imported.run().queues.is_empty());
1611 let warning = "skipped queue span 'permits' for request_id 'r1' because interval [110, 123] falls outside request interval [100, 120] beyond tolerance_ms=2";
1612 assert!(imported
1613 .warnings()
1614 .iter()
1615 .any(|w| w.message().contains(warning)));
1616 assert!(imported
1617 .run()
1618 .metadata
1619 .lifecycle_warnings
1620 .iter()
1621 .any(|w| w.contains(warning)));
1622 }
1623
1624 #[test]
1625 fn strict_mode_fails_for_out_of_window_stage() {
1626 let spans = vec![
1627 SpanRecord::new("req", 100, 120)
1628 .field(TT_KIND, "request")
1629 .field(TT_REQUEST_ID, "r1")
1630 .field(TT_ROUTE, "/a"),
1631 SpanRecord::new("stage", 97, 110)
1632 .field(TT_KIND, "stage")
1633 .field(TT_REQUEST_ID, "r1")
1634 .field(TT_STAGE, "db"),
1635 ];
1636 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
1637 assert!(matches!(err, ImportError::StrictViolation(_)));
1638 }
1639
1640 #[test]
1641 fn strict_mode_fails_for_out_of_window_queue() {
1642 let spans = vec![
1643 SpanRecord::new("req", 100, 120)
1644 .field(TT_KIND, "request")
1645 .field(TT_REQUEST_ID, "r1")
1646 .field(TT_ROUTE, "/a"),
1647 SpanRecord::new("queue", 110, 123)
1648 .field(TT_KIND, "queue")
1649 .field(TT_REQUEST_ID, "r1")
1650 .field(TT_QUEUE, "permits"),
1651 ];
1652 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
1653 assert!(matches!(err, ImportError::StrictViolation(_)));
1654 }
1655
1656 #[test]
1657 fn stage_starting_1ms_before_request_is_retained_with_tolerance() {
1658 let spans = vec![
1659 SpanRecord::new("req", 100, 120)
1660 .field(TT_KIND, "request")
1661 .field(TT_REQUEST_ID, "r1")
1662 .field(TT_ROUTE, "/a"),
1663 SpanRecord::new("stage", 99, 110)
1664 .field(TT_KIND, "stage")
1665 .field(TT_REQUEST_ID, "r1")
1666 .field(TT_STAGE, "db"),
1667 ];
1668 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1669 assert_eq!(imported.run().stages.len(), 1);
1670 }
1671
1672 #[test]
1673 fn queue_ending_1ms_after_request_is_retained_with_tolerance() {
1674 let spans = vec![
1675 SpanRecord::new("req", 100, 120)
1676 .field(TT_KIND, "request")
1677 .field(TT_REQUEST_ID, "r1")
1678 .field(TT_ROUTE, "/a"),
1679 SpanRecord::new("queue", 110, 121)
1680 .field(TT_KIND, "queue")
1681 .field(TT_REQUEST_ID, "r1")
1682 .field(TT_QUEUE, "permits"),
1683 ];
1684 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1685 assert_eq!(imported.run().queues.len(), 1);
1686 }
1687
1688 #[test]
1689 fn boundary_equal_stage_and_queue_are_accepted() {
1690 let spans = vec![
1691 SpanRecord::new("req", 100, 120)
1692 .field(TT_KIND, "request")
1693 .field(TT_REQUEST_ID, "r1")
1694 .field(TT_ROUTE, "/a"),
1695 SpanRecord::new("stage", 100, 120)
1696 .field(TT_KIND, "stage")
1697 .field(TT_REQUEST_ID, "r1")
1698 .field(TT_STAGE, "db"),
1699 SpanRecord::new("queue", 100, 120)
1700 .field(TT_KIND, "queue")
1701 .field(TT_REQUEST_ID, "r1")
1702 .field(TT_QUEUE, "permits"),
1703 ];
1704 let run = run_from_span_records(spans, ImportOptions::new("svc"))
1705 .unwrap()
1706 .run()
1707 .clone();
1708 assert_eq!(run.stages.len(), 1);
1709 assert_eq!(run.queues.len(), 1);
1710 }
1711
1712 #[test]
1713 fn zero_duration_request_with_boundary_equal_stage_and_queue_is_accepted() {
1714 let spans = vec![
1715 SpanRecord::new("req", 100, 100)
1716 .field(TT_KIND, "request")
1717 .field(TT_REQUEST_ID, "r1")
1718 .field(TT_ROUTE, "/a"),
1719 SpanRecord::new("stage", 100, 100)
1720 .field(TT_KIND, "stage")
1721 .field(TT_REQUEST_ID, "r1")
1722 .field(TT_STAGE, "db"),
1723 SpanRecord::new("queue", 100, 100)
1724 .field(TT_KIND, "queue")
1725 .field(TT_REQUEST_ID, "r1")
1726 .field(TT_QUEUE, "permits"),
1727 ];
1728 let run = run_from_span_records(spans, ImportOptions::new("svc"))
1729 .unwrap()
1730 .run()
1731 .clone();
1732 assert_eq!(run.requests[0].started_at_unix_ms, 100);
1733 assert_eq!(run.requests[0].finished_at_unix_ms, 100);
1734 assert_eq!(run.stages.len(), 1);
1735 assert_eq!(run.queues.len(), 1);
1736 }
1737
1738 #[test]
1739 fn non_strict_duplicate_request_id_skips_later_request() {
1740 let spans = vec![
1741 SpanRecord::new("req-1", 100, 120)
1742 .field(TT_KIND, "request")
1743 .field(TT_REQUEST_ID, "dup")
1744 .field(TT_ROUTE, "/a"),
1745 SpanRecord::new("req-2", 200, 260)
1746 .field(TT_KIND, "request")
1747 .field(TT_REQUEST_ID, "dup")
1748 .field(TT_ROUTE, "/b")
1749 .field(TT_OUTCOME, "error"),
1750 SpanRecord::new("stage-skipped", 210, 220)
1751 .field(TT_KIND, "stage")
1752 .field(TT_REQUEST_ID, "dup")
1753 .field(TT_STAGE, "downstream"),
1754 ];
1755 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1756 let run = imported.run();
1757 assert_eq!(run.requests.len(), 1);
1758 assert_eq!(run.requests[0].route, "/a");
1759 assert_eq!(run.stages.len(), 0);
1760 assert_eq!(run.truncation.dropped_requests, 0);
1761
1762 assert!(imported.warnings().iter().any(|w| w
1763 .message()
1764 .contains("duplicate tt.request_id 'dup' is an input-quality problem")));
1765 assert!(imported.warnings().iter().any(|w| w
1766 .message()
1767 .contains("skipped later duplicate request event")));
1768 assert!(imported.warnings().iter().any(|w| w
1769 .message()
1770 .contains("child stage/queue evidence outside the retained first request interval may also be skipped")));
1771 assert!(imported
1772 .run()
1773 .metadata
1774 .lifecycle_warnings
1775 .iter()
1776 .any(|w| w.contains("duplicate tt.request_id 'dup' is an input-quality problem")));
1777 }
1778
1779 #[test]
1780 fn non_strict_skipped_duplicate_missing_outcome_does_not_warn_outcome_defaulted() {
1781 let spans = vec![
1782 SpanRecord::new("req-1", 100, 120)
1783 .field(TT_KIND, "request")
1784 .field(TT_REQUEST_ID, "dup")
1785 .field(TT_ROUTE, "/a")
1786 .field(TT_OUTCOME, "ok"),
1787 SpanRecord::new("req-2", 200, 260)
1788 .field(TT_KIND, "request")
1789 .field(TT_REQUEST_ID, "dup")
1790 .field(TT_ROUTE, "/b"),
1791 ];
1792 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1793 let run = imported.run();
1794 assert_eq!(run.requests.len(), 1);
1795 assert_eq!(run.requests[0].route, "/a");
1796 assert!(imported.warnings().iter().any(|w| w
1797 .message()
1798 .contains("duplicate tt.request_id 'dup' is an input-quality problem")));
1799 assert!(!imported.warnings().iter().any(|w| w
1800 .message()
1801 .contains("missing optional 'tt.outcome'; assumed 'ok'")));
1802 assert!(!run
1803 .metadata
1804 .lifecycle_warnings
1805 .iter()
1806 .any(|w| w.contains("missing optional 'tt.outcome'; assumed 'ok'")));
1807 }
1808
1809 #[test]
1810 fn strict_duplicate_request_id_fails() {
1811 let spans = vec![
1812 SpanRecord::new("req-1", 100, 120)
1813 .field(TT_KIND, "request")
1814 .field(TT_REQUEST_ID, "dup")
1815 .field(TT_ROUTE, "/a"),
1816 SpanRecord::new("req-2", 101, 121)
1817 .field(TT_KIND, "request")
1818 .field(TT_REQUEST_ID, "dup")
1819 .field(TT_ROUTE, "/b"),
1820 ];
1821 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
1822 assert!(matches!(err, ImportError::StrictViolation(_)));
1823 }
1824
1825 #[test]
1826 fn overflow_duplicate_request_ids_beyond_max_requests_do_not_warn() {
1827 let spans = vec![
1828 SpanRecord::new("req-1", 100, 120)
1829 .field(TT_KIND, "request")
1830 .field(TT_REQUEST_ID, "r1")
1831 .field(TT_ROUTE, "/a"),
1832 SpanRecord::new("req-2", 101, 121)
1833 .field(TT_KIND, "request")
1834 .field(TT_REQUEST_ID, "r2")
1835 .field(TT_ROUTE, "/b"),
1836 SpanRecord::new("req-overflow", 102, 122)
1837 .field(TT_KIND, "request")
1838 .field(TT_REQUEST_ID, "r1")
1839 .field(TT_ROUTE, "/overflow"),
1840 ];
1841 let imported = run_from_span_records(
1842 spans,
1843 ImportOptions::new("svc").capture_limits_override(
1844 tailtriage_core::CaptureLimitsOverride {
1845 max_requests: Some(2),
1846 ..tailtriage_core::CaptureLimitsOverride::default()
1847 },
1848 ),
1849 )
1850 .unwrap();
1851 assert!(!imported
1852 .warnings()
1853 .iter()
1854 .any(|w| w.message().contains("duplicate tt.request_id")));
1855 }
1856
1857 #[test]
1858 fn invalid_extreme_timestamps_do_not_affect_metadata_bounds_or_default_run_id() {
1859 let spans = vec![
1860 SpanRecord::new("req", 100, 120)
1861 .field(TT_KIND, "request")
1862 .field(TT_REQUEST_ID, "r1")
1863 .field(TT_ROUTE, "/a"),
1864 SpanRecord::new("stage-extreme", 1, 1_000_000)
1865 .field(TT_KIND, "stage")
1866 .field(TT_REQUEST_ID, "r1")
1867 .field(TT_STAGE, "db"),
1868 SpanRecord::new("queue-extreme", 1, 1_000_000)
1869 .field(TT_KIND, "queue")
1870 .field(TT_REQUEST_ID, "r1")
1871 .field(TT_QUEUE, "permits"),
1872 ];
1873 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1874 let run = imported.run();
1875 assert_eq!(run.stages.len(), 0);
1876 assert_eq!(run.queues.len(), 0);
1877 assert_eq!(run.metadata.started_at_unix_ms, 100);
1878 assert_eq!(run.metadata.finished_at_unix_ms, 120);
1879 assert!(run.metadata.run_id.contains("tracing-import-100-120"));
1880 }
1881
1882 #[test]
1883 fn orphan_queue_does_not_affect_retained_bounds_or_default_run_id() {
1884 let spans = vec![
1885 SpanRecord::new("req", 100, 120)
1886 .field(TT_KIND, "request")
1887 .field(TT_REQUEST_ID, "r1")
1888 .field(TT_ROUTE, "/a"),
1889 SpanRecord::new("q", 1, 1_000_000)
1890 .field(TT_KIND, "queue")
1891 .field(TT_REQUEST_ID, "r-orphan")
1892 .field(TT_QUEUE, "permits"),
1893 ];
1894 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1895 let run = imported.run();
1896 assert_eq!(run.requests.len(), 1);
1897 assert_eq!(run.queues.len(), 0);
1898 assert_eq!(run.metadata.started_at_unix_ms, 100);
1899 assert_eq!(run.metadata.finished_at_unix_ms, 120);
1900 assert!(run.metadata.run_id.contains("tracing-import-100-120"));
1901 }
1902
1903 #[test]
1904 fn overflow_request_does_not_affect_metadata_bounds_or_run_id() {
1905 let limits = CaptureMode::Light.core_defaults();
1906 let mut spans = Vec::new();
1907 for index in 0..limits.max_requests {
1908 spans.push(
1909 SpanRecord::new(format!("req-{index}"), 100, 120)
1910 .field(TT_KIND, "request")
1911 .field(TT_REQUEST_ID, format!("r{index}"))
1912 .field(TT_ROUTE, "/a")
1913 .field(TT_OUTCOME, "ok"),
1914 );
1915 }
1916 spans.push(
1917 SpanRecord::new("overflow", 1, 1_000_000)
1918 .field(TT_KIND, "request")
1919 .field(TT_REQUEST_ID, "r-overflow")
1920 .field(TT_ROUTE, "/overflow"),
1921 );
1922 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1923 let run = imported.run();
1924 assert_eq!(run.requests.len(), limits.max_requests);
1925 assert_eq!(run.truncation.dropped_requests, 1);
1926 assert_eq!(run.metadata.started_at_unix_ms, 100);
1927 assert_eq!(run.metadata.finished_at_unix_ms, 120);
1928 assert!(run.metadata.run_id.contains("tracing-import-100-120"));
1929 assert!(!imported.warnings().iter().any(|w| w
1930 .message()
1931 .contains("missing optional 'tt.outcome'; assumed 'ok'")));
1932 }
1933
1934 #[test]
1935 fn overflow_stage_does_not_affect_metadata_bounds_or_success_warning() {
1936 let limits = CaptureMode::Light.core_defaults();
1937 let mut spans = vec![SpanRecord::new("req", 100, 120)
1938 .field(TT_KIND, "request")
1939 .field(TT_REQUEST_ID, "r1")
1940 .field(TT_ROUTE, "/a")
1941 .field(TT_OUTCOME, "ok")];
1942 for index in 0..limits.max_stages {
1943 spans.push(
1944 SpanRecord::new(format!("stage-{index}"), 101, 110)
1945 .field(TT_KIND, "stage")
1946 .field(TT_REQUEST_ID, "r1")
1947 .field(TT_STAGE, format!("s{index}"))
1948 .field(TT_SUCCESS, true),
1949 );
1950 }
1951 spans.push(
1952 SpanRecord::new("overflow-stage", 1, 1_000_000)
1953 .field(TT_KIND, "stage")
1954 .field(TT_REQUEST_ID, "r1")
1955 .field(TT_STAGE, "overflow-stage"),
1956 );
1957 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1958 let run = imported.run();
1959 assert_eq!(run.stages.len(), limits.max_stages);
1960 assert_eq!(run.truncation.dropped_stages, 0);
1961 assert_eq!(run.metadata.started_at_unix_ms, 100);
1962 assert_eq!(run.metadata.finished_at_unix_ms, 120);
1963 assert!(!imported.warnings().iter().any(|w| w
1964 .message()
1965 .contains("missing optional 'tt.success'; assumed true")));
1966 }
1967
1968 #[test]
1969 fn overflow_queue_does_not_affect_metadata_bounds() {
1970 let limits = CaptureMode::Light.core_defaults();
1971 let mut spans = vec![SpanRecord::new("req", 100, 120)
1972 .field(TT_KIND, "request")
1973 .field(TT_REQUEST_ID, "r1")
1974 .field(TT_ROUTE, "/a")
1975 .field(TT_OUTCOME, "ok")];
1976 for index in 0..limits.max_queues {
1977 spans.push(
1978 SpanRecord::new(format!("queue-{index}"), 101, 110)
1979 .field(TT_KIND, "queue")
1980 .field(TT_REQUEST_ID, "r1")
1981 .field(TT_QUEUE, format!("q{index}")),
1982 );
1983 }
1984 spans.push(
1985 SpanRecord::new("overflow-queue", 1, 1_000_000)
1986 .field(TT_KIND, "queue")
1987 .field(TT_REQUEST_ID, "r1")
1988 .field(TT_QUEUE, "overflow-queue"),
1989 );
1990 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
1991 let run = imported.run();
1992 assert_eq!(run.queues.len(), limits.max_queues);
1993 assert_eq!(run.truncation.dropped_queues, 0);
1994 assert_eq!(run.metadata.started_at_unix_ms, 100);
1995 assert_eq!(run.metadata.finished_at_unix_ms, 120);
1996 }
1997
1998 #[test]
1999 fn run_from_span_records_respects_import_mode_and_resolved_limits() {
2000 let spans = vec![
2001 SpanRecord::new("req-1", 100, 120)
2002 .field(TT_KIND, "request")
2003 .field(TT_REQUEST_ID, "r1")
2004 .field(TT_ROUTE, "/a"),
2005 SpanRecord::new("req-2", 101, 121)
2006 .field(TT_KIND, "request")
2007 .field(TT_REQUEST_ID, "r2")
2008 .field(TT_ROUTE, "/b"),
2009 SpanRecord::new("stage-1", 102, 110)
2010 .field(TT_KIND, "stage")
2011 .field(TT_REQUEST_ID, "r1")
2012 .field(TT_STAGE, "s1"),
2013 SpanRecord::new("stage-2", 103, 111)
2014 .field(TT_KIND, "stage")
2015 .field(TT_REQUEST_ID, "r1")
2016 .field(TT_STAGE, "s2"),
2017 SpanRecord::new("queue-1", 104, 112)
2018 .field(TT_KIND, "queue")
2019 .field(TT_REQUEST_ID, "r1")
2020 .field(TT_QUEUE, "q1"),
2021 SpanRecord::new("queue-2", 105, 113)
2022 .field(TT_KIND, "queue")
2023 .field(TT_REQUEST_ID, "r1")
2024 .field(TT_QUEUE, "q2"),
2025 ];
2026 let limits = tailtriage_core::CaptureLimitsOverride {
2027 max_requests: Some(1),
2028 max_stages: Some(1),
2029 max_queues: Some(1),
2030 ..tailtriage_core::CaptureLimitsOverride::default()
2031 };
2032 let imported = run_from_span_records(
2033 spans,
2034 ImportOptions::new("svc")
2035 .mode(CaptureMode::Investigation)
2036 .capture_limits_override(limits),
2037 )
2038 .unwrap();
2039 let run = imported.run();
2040 let effective = run
2041 .metadata
2042 .effective_core_config
2043 .as_ref()
2044 .expect("effective core config should be present");
2045 assert_eq!(run.metadata.mode, CaptureMode::Investigation);
2046 assert_eq!(effective.capture_limits.max_requests, 1);
2047 assert_eq!(effective.capture_limits.max_stages, 1);
2048 assert_eq!(effective.capture_limits.max_queues, 1);
2049 assert!(!effective.strict_lifecycle);
2050 assert_eq!(run.requests.len(), 1);
2051 assert_eq!(run.stages.len(), 1);
2052 assert_eq!(run.queues.len(), 1);
2053 assert_eq!(run.truncation.dropped_requests, 1);
2054 assert_eq!(run.truncation.dropped_stages, 1);
2055 assert_eq!(run.truncation.dropped_queues, 1);
2056 }
2057
2058 #[test]
2059 fn retained_request_missing_outcome_still_warns() {
2060 let spans = vec![SpanRecord::new("req", 100, 120)
2061 .field(TT_KIND, "request")
2062 .field(TT_REQUEST_ID, "r1")
2063 .field(TT_ROUTE, "/a")];
2064 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2065 assert!(imported.warnings().iter().any(|w| w
2066 .message()
2067 .contains("missing optional 'tt.outcome'; assumed 'ok'")));
2068 }
2069
2070 #[test]
2071 fn retained_stage_missing_success_still_warns() {
2072 let spans = vec![
2073 SpanRecord::new("req", 100, 120)
2074 .field(TT_KIND, "request")
2075 .field(TT_REQUEST_ID, "r1")
2076 .field(TT_ROUTE, "/a")
2077 .field(TT_OUTCOME, "ok"),
2078 SpanRecord::new("stage", 105, 115)
2079 .field(TT_KIND, "stage")
2080 .field(TT_REQUEST_ID, "r1")
2081 .field(TT_STAGE, "db"),
2082 ];
2083 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2084 assert!(imported.warnings().iter().any(|w| w
2085 .message()
2086 .contains("missing optional 'tt.success'; assumed true")));
2087 }
2088
2089 #[test]
2090 fn matched_request_stage_queue_are_retained() {
2091 let spans = vec![
2092 SpanRecord::new("req", 100, 120)
2093 .field(TT_KIND, "request")
2094 .field(TT_REQUEST_ID, "r1")
2095 .field(TT_ROUTE, "/a"),
2096 SpanRecord::new("st", 105, 115)
2097 .field(TT_KIND, "stage")
2098 .field(TT_REQUEST_ID, "r1")
2099 .field(TT_STAGE, "db"),
2100 SpanRecord::new("q", 102, 103)
2101 .field(TT_KIND, "queue")
2102 .field(TT_REQUEST_ID, "r1")
2103 .field(TT_QUEUE, "permits"),
2104 ];
2105 let run = run_from_span_records(spans, ImportOptions::new("svc"))
2106 .unwrap()
2107 .run()
2108 .clone();
2109 assert_eq!(run.requests.len(), 1);
2110 assert_eq!(run.stages.len(), 1);
2111 assert_eq!(run.queues.len(), 1);
2112 }
2113
2114 #[test]
2115 fn missing_optional_fields_default() {
2116 let spans = vec![
2117 SpanRecord::new("req", 1, 2)
2118 .field(TT_KIND, "request")
2119 .field(TT_REQUEST_ID, "r1")
2120 .field(TT_ROUTE, "/"),
2121 SpanRecord::new("st", 1, 2)
2122 .field(TT_KIND, "stage")
2123 .field(TT_REQUEST_ID, "r1")
2124 .field(TT_STAGE, "s1"),
2125 SpanRecord::new("q", 1, 2)
2126 .field(TT_KIND, "queue")
2127 .field(TT_REQUEST_ID, "r1")
2128 .field(TT_QUEUE, "q1"),
2129 ];
2130 let run = run_from_span_records(spans, ImportOptions::new("svc"))
2131 .unwrap()
2132 .run()
2133 .clone();
2134 assert_eq!(run.requests[0].outcome, "ok");
2135 assert!(run.stages[0].success);
2136 assert_eq!(run.queues[0].depth_at_start, None);
2137 }
2138
2139 #[test]
2140 fn missing_required_field_warns_and_skips_non_strict() {
2141 let spans = vec![SpanRecord::new("req", 1, 2)
2142 .field(TT_KIND, "request")
2143 .field(TT_REQUEST_ID, "r1")];
2144 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2145 assert_eq!(imported.run().requests.len(), 0);
2146 assert_eq!(imported.warnings().len(), 1);
2147 }
2148
2149 #[test]
2150 fn missing_required_field_errors_in_strict() {
2151 let spans = vec![SpanRecord::new("req", 1, 2)
2152 .field(TT_KIND, "request")
2153 .field(TT_REQUEST_ID, "r1")];
2154 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2155 assert!(matches!(err, ImportError::StrictViolation(_)));
2156 }
2157
2158 #[test]
2159 fn unknown_kind_warns_non_strict() {
2160 let spans = vec![SpanRecord::new("x", 1, 2).field(TT_KIND, "wat")];
2161 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2162 assert_eq!(imported.warnings().len(), 1);
2163 assert!(imported
2164 .run()
2165 .metadata
2166 .lifecycle_warnings
2167 .iter()
2168 .any(|warning| warning.contains("unknown tt.kind 'wat'")));
2169 }
2170
2171 #[test]
2172 fn unknown_kind_errors_in_strict() {
2173 let spans = vec![SpanRecord::new("x", 1, 2).field(TT_KIND, "wat")];
2174 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2175 assert!(matches!(err, ImportError::StrictViolation(_)));
2176 }
2177
2178 #[test]
2179 fn span_without_kind_ignored_silently() {
2180 let spans = vec![SpanRecord::new("x", 1, 2).field("a", "b")];
2181 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2182 assert!(imported.warnings().is_empty());
2183 }
2184
2185 #[test]
2186 fn tailtriage_tagged_span_missing_kind_warns_or_errors() {
2187 let spans = vec![SpanRecord::new("http.request", 1, 2)
2188 .field(TT_REQUEST_ID, "r1")
2189 .field(TT_ROUTE, "/a")];
2190 let imported = run_from_span_records(spans.clone(), ImportOptions::new("svc")).unwrap();
2191 assert_eq!(imported.run().requests.len(), 0);
2192 assert!(imported.warnings().iter().any(|w| w
2193 .message()
2194 .contains("missing required field 'tt.kind' in span 'http.request'")));
2195
2196 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2197 assert!(matches!(err, ImportError::StrictViolation(_)));
2198 }
2199
2200 #[test]
2201 fn missing_optional_defaults_emit_aggregate_warnings() {
2202 let spans = vec![
2203 SpanRecord::new("req1", 1, 2)
2204 .field(TT_KIND, "request")
2205 .field(TT_REQUEST_ID, "r1")
2206 .field(TT_ROUTE, "/a"),
2207 SpanRecord::new("req2", 1, 2)
2208 .field(TT_KIND, "request")
2209 .field(TT_REQUEST_ID, "r2")
2210 .field(TT_ROUTE, "/b"),
2211 SpanRecord::new("st1", 1, 2)
2212 .field(TT_KIND, "stage")
2213 .field(TT_REQUEST_ID, "r1")
2214 .field(TT_STAGE, "db"),
2215 SpanRecord::new("st2", 1, 2)
2216 .field(TT_KIND, "stage")
2217 .field(TT_REQUEST_ID, "r2")
2218 .field(TT_STAGE, "cache"),
2219 SpanRecord::new("q", 1, 2)
2220 .field(TT_KIND, "queue")
2221 .field(TT_REQUEST_ID, "r1")
2222 .field(TT_QUEUE, "permits"),
2223 ];
2224 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2225 let msgs = imported
2226 .warnings()
2227 .iter()
2228 .map(ImportWarning::message)
2229 .collect::<Vec<_>>();
2230 assert!(msgs
2231 .iter()
2232 .any(|m| m.contains("2 request span(s) missing optional 'tt.outcome'; assumed 'ok'")));
2233 assert!(msgs
2234 .iter()
2235 .any(|m| m.contains("2 stage span(s) missing optional 'tt.success'; assumed true")));
2236 assert!(!msgs.iter().any(|m| m.contains("tt.depth_at_start")));
2237 let lifecycle_warnings = &imported.run().metadata.lifecycle_warnings;
2238 assert!(lifecycle_warnings
2239 .iter()
2240 .any(|m| m.contains("2 request span(s) missing optional 'tt.outcome'; assumed 'ok'")));
2241 assert!(lifecycle_warnings
2242 .iter()
2243 .any(|m| m.contains("2 stage span(s) missing optional 'tt.success'; assumed true")));
2244 assert_eq!(
2245 lifecycle_warnings
2246 .iter()
2247 .filter(|m| m.contains("missing optional 'tt.outcome'; assumed 'ok'"))
2248 .count(),
2249 1
2250 );
2251 assert_eq!(
2252 lifecycle_warnings
2253 .iter()
2254 .filter(|m| m.contains("missing optional 'tt.success'; assumed true"))
2255 .count(),
2256 1
2257 );
2258 }
2259
2260 #[test]
2261 fn inverted_timestamps_warn_or_error() {
2262 let spans = vec![SpanRecord::new("req", 5, 4)
2263 .field(TT_KIND, "request")
2264 .field(TT_REQUEST_ID, "r1")
2265 .field(TT_ROUTE, "/")];
2266 let imported = run_from_span_records(spans.clone(), ImportOptions::new("svc")).unwrap();
2267 assert_eq!(imported.run().requests.len(), 0);
2268 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2269 assert!(matches!(err, ImportError::StrictViolation(_)));
2270 }
2271
2272 #[test]
2273 fn run_from_span_records_validates_service_name_before_strict_span_parsing() {
2274 let spans = vec![SpanRecord::new("bad", 10, 20).field(TT_KIND, 123_u64)];
2275 let err = run_from_span_records(spans, ImportOptions::new(" ").strict(true)).unwrap_err();
2276 assert!(matches!(err, ImportError::EmptyServiceName));
2277 }
2278
2279 #[test]
2280 fn run_from_span_records_empty_input_uses_equal_start_finish_finalized() {
2281 let imported = run_from_span_records(Vec::new(), ImportOptions::new("svc")).unwrap();
2282 assert!(imported.run().requests.is_empty());
2283 assert!(imported.run().stages.is_empty());
2284 assert!(imported.run().queues.is_empty());
2285 assert_eq!(
2286 imported.run().metadata.finished_at_unix_ms,
2287 imported.run().metadata.started_at_unix_ms
2288 );
2289 assert_eq!(
2290 imported.run().metadata.finalized_at_unix_ms,
2291 Some(imported.run().metadata.finished_at_unix_ms)
2292 );
2293 }
2294
2295 #[test]
2296 fn run_from_span_records_uses_schema_v1_finalization_semantics() {
2297 let spans = vec![SpanRecord::new("req", 10, 20)
2298 .field(TT_KIND, "request")
2299 .field(TT_REQUEST_ID, "r1")
2300 .field(TT_ROUTE, "/")];
2301 let run = run_from_span_records(spans, ImportOptions::new("svc"))
2302 .unwrap()
2303 .run()
2304 .clone();
2305 assert_eq!(run.metadata.started_at_unix_ms, 10);
2306 assert_eq!(run.metadata.finished_at_unix_ms, 20);
2307 assert_eq!(run.metadata.finalized_at_unix_ms, Some(20));
2308 }
2309
2310 #[test]
2311 fn run_from_span_records_preserves_computed_import_run_id() {
2312 let spans = vec![SpanRecord::new("req", 10, 20)
2313 .field(TT_KIND, "request")
2314 .field(TT_REQUEST_ID, "r1")
2315 .field(TT_ROUTE, "/")];
2316 let run = run_from_span_records(spans, ImportOptions::new("svc"))
2317 .unwrap()
2318 .run()
2319 .clone();
2320 assert_eq!(run.metadata.run_id, "tracing-import-10-20");
2321 }
2322
2323 #[test]
2324 fn run_from_span_records_preserves_explicit_import_run_id() {
2325 let spans = vec![SpanRecord::new("req", 10, 20)
2326 .field(TT_KIND, "request")
2327 .field(TT_REQUEST_ID, "r1")
2328 .field(TT_ROUTE, "/")];
2329 let run = run_from_span_records(spans, ImportOptions::new("svc").run_id("explicit-run"))
2330 .unwrap()
2331 .run()
2332 .clone();
2333 assert_eq!(run.metadata.run_id, "explicit-run");
2334 }
2335
2336 #[test]
2337 fn runtime_snapshots_and_inflight_are_empty() {
2338 let imported = run_from_span_records(Vec::new(), ImportOptions::new("svc")).unwrap();
2339 assert!(imported.run().runtime_snapshots.is_empty());
2340 assert!(imported.run().inflight.is_empty());
2341 }
2342
2343 #[test]
2344 fn ordinary_span_without_kind_does_not_affect_metadata_bounds() {
2345 let spans = vec![
2346 SpanRecord::new("ordinary", 1, 1_000).field("foo", "bar"),
2347 SpanRecord::new("req", 10, 20)
2348 .field(TT_KIND, "request")
2349 .field(TT_REQUEST_ID, "r1")
2350 .field(TT_ROUTE, "/"),
2351 ];
2352 let run = run_from_span_records(spans, ImportOptions::new("svc"))
2353 .unwrap()
2354 .run()
2355 .clone();
2356 assert_eq!(run.metadata.started_at_unix_ms, 10);
2357 assert_eq!(run.metadata.finished_at_unix_ms, 20);
2358 }
2359
2360 #[test]
2361 fn unknown_kind_does_not_affect_metadata_bounds_and_is_durable_lifecycle_warning() {
2362 let spans = vec![
2363 SpanRecord::new("unknown", 1, 1_000).field(TT_KIND, "wat"),
2364 SpanRecord::new("req", 10, 20)
2365 .field(TT_KIND, "request")
2366 .field(TT_REQUEST_ID, "r1")
2367 .field(TT_ROUTE, "/"),
2368 ];
2369 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2370 assert_eq!(imported.run().metadata.started_at_unix_ms, 10);
2371 assert_eq!(imported.run().metadata.finished_at_unix_ms, 20);
2372 assert!(imported
2373 .run()
2374 .metadata
2375 .lifecycle_warnings
2376 .iter()
2377 .any(|w| w.contains("unknown tt.kind")));
2378 }
2379
2380 #[test]
2381 fn non_string_kind_warns_non_strict_and_errors_strict() {
2382 let bad = SpanRecord::new("bad", 1, 2).field(TT_KIND, true);
2383 let imported = run_from_span_records(vec![bad.clone()], ImportOptions::new("svc")).unwrap();
2384 assert_eq!(imported.warnings().len(), 1);
2385 assert!(run_from_span_records(vec![bad], ImportOptions::new("svc").strict(true)).is_err());
2386 }
2387
2388 #[test]
2389 fn non_string_required_and_optional_fields_warn_non_strict_and_error_strict() {
2390 let bad_route = SpanRecord::new("req", 1, 2)
2391 .field(TT_KIND, "request")
2392 .field(TT_REQUEST_ID, "r1")
2393 .field(TT_ROUTE, true);
2394 let imported =
2395 run_from_span_records(vec![bad_route.clone()], ImportOptions::new("svc")).unwrap();
2396 assert!(imported.run().requests.is_empty());
2397 assert_eq!(imported.warnings().len(), 1);
2398 assert!(
2399 run_from_span_records(vec![bad_route], ImportOptions::new("svc").strict(true)).is_err()
2400 );
2401
2402 let bad_outcome = SpanRecord::new("req", 1, 2)
2403 .field(TT_KIND, "request")
2404 .field(TT_REQUEST_ID, "r1")
2405 .field(TT_ROUTE, "/")
2406 .field(TT_OUTCOME, 7_u64);
2407 let imported =
2408 run_from_span_records(vec![bad_outcome.clone()], ImportOptions::new("svc")).unwrap();
2409 assert!(imported.run().requests.is_empty());
2410 assert_eq!(imported.warnings().len(), 1);
2411 assert!(
2412 run_from_span_records(vec![bad_outcome], ImportOptions::new("svc").strict(true))
2413 .is_err()
2414 );
2415 }
2416
2417 #[test]
2418 fn whitespace_only_request_id_non_strict_skips_request_and_warns() {
2419 let spans = vec![SpanRecord::new("req", 1, 2)
2420 .field(TT_KIND, "request")
2421 .field(TT_REQUEST_ID, " ")
2422 .field(TT_ROUTE, "/")];
2423 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2424 assert!(imported.run().requests.is_empty());
2425 assert!(imported.warnings().iter().any(|w| {
2426 w.message()
2427 .contains("invalid field 'tt.request_id' in span 'req'")
2428 && w.message().contains("cannot be empty or whitespace")
2429 }));
2430 }
2431
2432 #[test]
2433 fn whitespace_only_route_non_strict_skips_request_and_warns() {
2434 let spans = vec![SpanRecord::new("req", 1, 2)
2435 .field(TT_KIND, "request")
2436 .field(TT_REQUEST_ID, "r1")
2437 .field(TT_ROUTE, " \t")];
2438 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2439 assert!(imported.run().requests.is_empty());
2440 assert!(imported.warnings().iter().any(|w| {
2441 w.message()
2442 .contains("invalid field 'tt.route' in span 'req'")
2443 && w.message().contains("cannot be empty or whitespace")
2444 }));
2445 }
2446
2447 #[test]
2448 fn whitespace_only_stage_non_strict_skips_stage_and_warns() {
2449 let spans = vec![
2450 SpanRecord::new("req", 1, 3)
2451 .field(TT_KIND, "request")
2452 .field(TT_REQUEST_ID, "r1")
2453 .field(TT_ROUTE, "/"),
2454 SpanRecord::new("stage", 1, 2)
2455 .field(TT_KIND, "stage")
2456 .field(TT_REQUEST_ID, "r1")
2457 .field(TT_STAGE, " "),
2458 ];
2459 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2460 assert!(imported.run().stages.is_empty());
2461 assert!(imported.warnings().iter().any(|w| {
2462 w.message()
2463 .contains("invalid field 'tt.stage' in span 'stage'")
2464 && w.message().contains("cannot be empty or whitespace")
2465 }));
2466 }
2467
2468 #[test]
2469 fn whitespace_only_queue_non_strict_skips_queue_and_warns() {
2470 let spans = vec![
2471 SpanRecord::new("req", 1, 3)
2472 .field(TT_KIND, "request")
2473 .field(TT_REQUEST_ID, "r1")
2474 .field(TT_ROUTE, "/"),
2475 SpanRecord::new("queue", 1, 2)
2476 .field(TT_KIND, "queue")
2477 .field(TT_REQUEST_ID, "r1")
2478 .field(TT_QUEUE, " "),
2479 ];
2480 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2481 assert!(imported.run().queues.is_empty());
2482 assert!(imported.warnings().iter().any(|w| {
2483 w.message()
2484 .contains("invalid field 'tt.queue' in span 'queue'")
2485 && w.message().contains("cannot be empty or whitespace")
2486 }));
2487 }
2488
2489 #[test]
2490 fn whitespace_only_required_field_strict_returns_strict_violation() {
2491 let spans = vec![SpanRecord::new("req", 1, 2)
2492 .field(TT_KIND, "request")
2493 .field(TT_REQUEST_ID, " ")
2494 .field(TT_ROUTE, "/")];
2495 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2496 assert!(matches!(err, ImportError::StrictViolation(_)));
2497 assert!(err
2498 .to_string()
2499 .contains("invalid field 'tt.request_id' in span 'req'"));
2500 }
2501
2502 #[test]
2503 fn builtin_request_outcomes_are_retained_exactly() {
2504 let spans = RECOMMENDED_OUTCOME_LABELS
2505 .iter()
2506 .enumerate()
2507 .map(|(idx, outcome)| {
2508 SpanRecord::new("req", idx as u64 + 1, idx as u64 + 2)
2509 .field(TT_KIND, "request")
2510 .field(TT_REQUEST_ID, format!("r{idx}"))
2511 .field(TT_ROUTE, "/")
2512 .field(TT_OUTCOME, *outcome)
2513 })
2514 .collect::<Vec<_>>();
2515 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2516 let retained = imported
2517 .run()
2518 .requests
2519 .iter()
2520 .map(|request| request.outcome.as_str())
2521 .collect::<Vec<_>>();
2522 assert_eq!(retained, RECOMMENDED_OUTCOME_LABELS);
2523 }
2524
2525 #[test]
2526 fn missing_outcome_defaults_ok_and_warns() {
2527 let spans = vec![SpanRecord::new("req", 1, 2)
2528 .field(TT_KIND, "request")
2529 .field(TT_REQUEST_ID, "r1")
2530 .field(TT_ROUTE, "/")];
2531 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2532 assert_eq!(imported.run().requests.len(), 1);
2533 assert_eq!(imported.run().requests[0].outcome, "ok");
2534 assert!(imported.warnings().iter().any(|w| w
2535 .message()
2536 .contains("missing optional 'tt.outcome'; assumed 'ok'")));
2537 }
2538
2539 #[test]
2540 fn custom_outcome_is_accepted_and_preserved_exactly() {
2541 let spans = vec![SpanRecord::new("http.request", 1, 2)
2542 .field(TT_KIND, "request")
2543 .field(TT_REQUEST_ID, "r1")
2544 .field(TT_ROUTE, "/")
2545 .field(TT_OUTCOME, "cache_miss_fallback")];
2546 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2547 assert_eq!(imported.run().requests.len(), 1);
2548 assert_eq!(imported.run().requests[0].outcome, "cache_miss_fallback");
2549 }
2550
2551 #[test]
2552 fn whitespace_only_outcome_non_strict_skips_request_and_warns() {
2553 let spans = vec![SpanRecord::new("http.request", 1, 2)
2554 .field(TT_KIND, "request")
2555 .field(TT_REQUEST_ID, "r1")
2556 .field(TT_ROUTE, "/")
2557 .field(TT_OUTCOME, " ")];
2558 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2559 assert!(imported.run().requests.is_empty());
2560 assert!(imported.warnings().iter().any(|w| w
2561 .message()
2562 .contains("invalid field 'tt.outcome' in span 'http.request': expected non-empty, non-whitespace string")));
2563 }
2564
2565 #[test]
2566 fn whitespace_only_outcome_strict_fails() {
2567 let spans = vec![SpanRecord::new("http.request", 1, 2)
2568 .field(TT_KIND, "request")
2569 .field(TT_REQUEST_ID, "r1")
2570 .field(TT_ROUTE, "/")
2571 .field(TT_OUTCOME, " \t")];
2572 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2573 assert!(matches!(err, ImportError::StrictViolation(_)));
2574 assert!(err
2575 .to_string()
2576 .contains("invalid field 'tt.outcome' in span 'http.request': expected non-empty, non-whitespace string"));
2577 }
2578
2579 #[test]
2580 fn non_string_outcome_non_strict_skips_request_and_warns() {
2581 let spans = vec![SpanRecord::new("http.request", 1, 2)
2582 .field(TT_KIND, "request")
2583 .field(TT_REQUEST_ID, "r1")
2584 .field(TT_ROUTE, "/")
2585 .field(TT_OUTCOME, 42_u64)];
2586 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2587 assert!(imported.run().requests.is_empty());
2588 assert!(imported.warnings().iter().any(|w| w
2589 .message()
2590 .contains("invalid field 'tt.outcome' in span 'http.request': expected string")));
2591 }
2592
2593 #[test]
2594 fn non_string_outcome_strict_fails() {
2595 let spans = vec![SpanRecord::new("http.request", 1, 2)
2596 .field(TT_KIND, "request")
2597 .field(TT_REQUEST_ID, "r1")
2598 .field(TT_ROUTE, "/")
2599 .field(TT_OUTCOME, false)];
2600 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true)).unwrap_err();
2601 assert!(matches!(err, ImportError::StrictViolation(_)));
2602 assert!(err
2603 .to_string()
2604 .contains("invalid field 'tt.outcome' in span 'http.request': expected string"));
2605 }
2606
2607 #[test]
2608 fn native_other_outcome_round_trips_through_tracing_style_outcome_field() {
2609 let native = tailtriage_core::Outcome::Other("custom".to_owned());
2610 let spans = vec![SpanRecord::new("http.request", 1, 2)
2611 .field(TT_KIND, "request")
2612 .field(TT_REQUEST_ID, "r1")
2613 .field(TT_ROUTE, "/")
2614 .field(TT_OUTCOME, native.as_str())];
2615 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2616 assert_eq!(imported.run().requests.len(), 1);
2617 assert_eq!(imported.run().requests[0].outcome, native.as_str());
2618 }
2619
2620 #[test]
2621 fn invalid_whitespace_outcome_skips_child_spans_via_existing_correlation_logic() {
2622 let spans = vec![
2623 SpanRecord::new("http.request", 1_000, 2_000)
2624 .field(TT_KIND, "request")
2625 .field(TT_REQUEST_ID, "r1")
2626 .field(TT_ROUTE, "/")
2627 .field(TT_OUTCOME, " "),
2628 SpanRecord::new("db.stage", 1_100, 1_200)
2629 .field(TT_KIND, "stage")
2630 .field(TT_REQUEST_ID, "r1")
2631 .field(TT_STAGE, "db")
2632 .field(TT_SUCCESS, true),
2633 SpanRecord::new("worker.queue", 1_300, 1_350)
2634 .field(TT_KIND, "queue")
2635 .field(TT_REQUEST_ID, "r1")
2636 .field(TT_QUEUE, "worker"),
2637 ];
2638 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2639 assert!(imported.run().requests.is_empty());
2640 assert!(imported.run().stages.is_empty());
2641 assert!(imported.run().queues.is_empty());
2642 assert!(imported.warnings().iter().any(|w| w.message().contains(
2643 "skipped stage span for request_id 'r1' because no valid matching request event was imported"
2644 )));
2645 assert!(imported.warnings().iter().any(|w| w.message().contains(
2646 "skipped queue span for request_id 'r1' because no valid matching request event was imported"
2647 )));
2648 }
2649
2650 #[test]
2651 fn strict_mode_duplicate_request_id_overflow_keeps_retained_children() {
2652 let spans = vec![
2653 SpanRecord::new("req-1", 100, 200)
2654 .field(TT_KIND, "request")
2655 .field(TT_REQUEST_ID, "r1")
2656 .field(TT_ROUTE, "/a"),
2657 SpanRecord::new("st-1", 120, 150)
2658 .field(TT_KIND, "stage")
2659 .field(TT_REQUEST_ID, "r1")
2660 .field(TT_STAGE, "db"),
2661 SpanRecord::new("q-1", 130, 140)
2662 .field(TT_KIND, "queue")
2663 .field(TT_REQUEST_ID, "r1")
2664 .field(TT_QUEUE, "permits"),
2665 SpanRecord::new("req-2", 300, 400)
2666 .field(TT_KIND, "request")
2667 .field(TT_REQUEST_ID, "r1")
2668 .field(TT_ROUTE, "/a"),
2669 ];
2670 let imported = run_from_span_records(
2671 spans,
2672 ImportOptions::new("checkout")
2673 .strict(true)
2674 .capture_limits_override(tailtriage_core::CaptureLimitsOverride {
2675 max_requests: Some(1),
2676 max_stages: None,
2677 max_queues: None,
2678 ..tailtriage_core::CaptureLimitsOverride::default()
2679 }),
2680 )
2681 .expect("strict import should keep children that match retained request interval");
2682
2683 assert_eq!(imported.run().requests.len(), 1);
2684 assert_eq!(imported.run().requests[0].request_id, "r1");
2685 assert_eq!(imported.run().requests[0].started_at_unix_ms, 100);
2686 assert_eq!(imported.run().requests[0].finished_at_unix_ms, 200);
2687 assert_eq!(imported.run().stages.len(), 1);
2688 assert_eq!(imported.run().stages[0].request_id, "r1");
2689 assert_eq!(imported.run().stages[0].started_at_unix_ms, 120);
2690 assert_eq!(imported.run().stages[0].finished_at_unix_ms, 150);
2691 assert_eq!(imported.run().queues.len(), 1);
2692 assert_eq!(imported.run().queues[0].request_id, "r1");
2693 assert_eq!(imported.run().queues[0].waited_from_unix_ms, 130);
2694 assert_eq!(imported.run().queues[0].waited_until_unix_ms, 140);
2695 assert_eq!(imported.run().truncation.dropped_requests, 1);
2696 assert_eq!(imported.run().truncation.dropped_stages, 0);
2697 assert_eq!(imported.run().truncation.dropped_queues, 0);
2698 }
2699
2700 #[test]
2701 fn strict_mode_duplicate_request_id_overflow_only_children_fail_outside_interval() {
2702 let spans = vec![
2703 SpanRecord::new("req-1", 100, 200)
2704 .field(TT_KIND, "request")
2705 .field(TT_REQUEST_ID, "r1")
2706 .field(TT_ROUTE, "/a"),
2707 SpanRecord::new("req-2", 300, 400)
2708 .field(TT_KIND, "request")
2709 .field(TT_REQUEST_ID, "r1")
2710 .field(TT_ROUTE, "/a"),
2711 SpanRecord::new("st-1", 320, 350)
2712 .field(TT_KIND, "stage")
2713 .field(TT_REQUEST_ID, "r1")
2714 .field(TT_STAGE, "db"),
2715 SpanRecord::new("q-1", 330, 340)
2716 .field(TT_KIND, "queue")
2717 .field(TT_REQUEST_ID, "r1")
2718 .field(TT_QUEUE, "permits"),
2719 ];
2720 let err = run_from_span_records(
2721 spans,
2722 ImportOptions::new("checkout")
2723 .strict(true)
2724 .capture_limits_override(tailtriage_core::CaptureLimitsOverride {
2725 max_requests: Some(1),
2726 max_stages: None,
2727 max_queues: None,
2728 ..tailtriage_core::CaptureLimitsOverride::default()
2729 }),
2730 )
2731 .expect_err("strict import should fail when child only matches overflow duplicate request");
2732 assert!(matches!(err, ImportError::StrictViolation(_)));
2733 let msg = err.to_string();
2734 assert!(msg.contains("falls outside request interval"));
2735 assert!(!msg.contains("valid but not retained due to max_requests"));
2736 }
2737
2738 #[test]
2739 fn non_strict_duplicate_request_id_overflow_only_children_warn_outside_interval() {
2740 let spans = vec![
2741 SpanRecord::new("req-1", 100, 200)
2742 .field(TT_KIND, "request")
2743 .field(TT_REQUEST_ID, "r1")
2744 .field(TT_ROUTE, "/a"),
2745 SpanRecord::new("req-2", 300, 400)
2746 .field(TT_KIND, "request")
2747 .field(TT_REQUEST_ID, "r1")
2748 .field(TT_ROUTE, "/a"),
2749 SpanRecord::new("st-1", 320, 350)
2750 .field(TT_KIND, "stage")
2751 .field(TT_REQUEST_ID, "r1")
2752 .field(TT_STAGE, "db"),
2753 SpanRecord::new("q-1", 330, 340)
2754 .field(TT_KIND, "queue")
2755 .field(TT_REQUEST_ID, "r1")
2756 .field(TT_QUEUE, "permits"),
2757 ];
2758 let imported = run_from_span_records(
2759 spans,
2760 ImportOptions::new("checkout").capture_limits_override(
2761 tailtriage_core::CaptureLimitsOverride {
2762 max_requests: Some(1),
2763 max_stages: None,
2764 max_queues: None,
2765 ..tailtriage_core::CaptureLimitsOverride::default()
2766 },
2767 ),
2768 )
2769 .expect("non-strict import should succeed with warnings");
2770
2771 assert_eq!(imported.run().requests.len(), 1);
2772 assert_eq!(imported.run().stages.len(), 0);
2773 assert_eq!(imported.run().queues.len(), 0);
2774 assert_eq!(imported.run().truncation.dropped_requests, 1);
2775 assert_eq!(imported.run().truncation.dropped_stages, 0);
2776 assert_eq!(imported.run().truncation.dropped_queues, 0);
2777
2778 let warning_msgs: Vec<&str> = imported
2779 .warnings()
2780 .iter()
2781 .map(ImportWarning::message)
2782 .collect();
2783 assert!(warning_msgs
2784 .iter()
2785 .any(|msg| msg.contains("falls outside request interval")));
2786 assert!(warning_msgs
2787 .iter()
2788 .all(|msg| !msg.contains("valid but not retained due to max_requests")));
2789
2790 let lifecycle_warnings = &imported.run().metadata.lifecycle_warnings;
2791 assert!(lifecycle_warnings
2792 .iter()
2793 .any(|msg| msg.contains("falls outside request interval")));
2794 assert!(lifecycle_warnings
2795 .iter()
2796 .all(|msg| !msg.contains("valid but not retained due to max_requests")));
2797 }
2798 #[test]
2799 fn strict_mode_max_requests_overflow_children_are_retention_fallout() {
2800 let spans = vec![
2801 SpanRecord::new("req-1", 100, 200)
2802 .field(TT_KIND, "request")
2803 .field(TT_REQUEST_ID, "r1")
2804 .field(TT_ROUTE, "/a"),
2805 SpanRecord::new("st-1", 120, 150)
2806 .field(TT_KIND, "stage")
2807 .field(TT_REQUEST_ID, "r1")
2808 .field(TT_STAGE, "db"),
2809 SpanRecord::new("q-1", 121, 130)
2810 .field(TT_KIND, "queue")
2811 .field(TT_REQUEST_ID, "r1")
2812 .field(TT_QUEUE, "permits"),
2813 SpanRecord::new("req-2", 300, 400)
2814 .field(TT_KIND, "request")
2815 .field(TT_REQUEST_ID, "r2")
2816 .field(TT_ROUTE, "/a"),
2817 SpanRecord::new("st-2", 320, 350)
2818 .field(TT_KIND, "stage")
2819 .field(TT_REQUEST_ID, "r2")
2820 .field(TT_STAGE, "db"),
2821 SpanRecord::new("q-2", 321, 330)
2822 .field(TT_KIND, "queue")
2823 .field(TT_REQUEST_ID, "r2")
2824 .field(TT_QUEUE, "permits"),
2825 ];
2826 let imported = run_from_span_records(
2827 spans,
2828 ImportOptions::new("checkout")
2829 .strict(true)
2830 .capture_limits_override(tailtriage_core::CaptureLimitsOverride {
2831 max_requests: Some(1),
2832 max_stages: None,
2833 max_queues: None,
2834 ..tailtriage_core::CaptureLimitsOverride::default()
2835 }),
2836 )
2837 .expect("strict import should succeed for valid overflow request children");
2838
2839 assert_eq!(imported.run().requests.len(), 1);
2840 assert_eq!(imported.run().requests[0].request_id, "r1");
2841 assert_eq!(imported.run().stages.len(), 1);
2842 assert_eq!(imported.run().stages[0].request_id, "r1");
2843 assert_eq!(imported.run().queues.len(), 1);
2844 assert_eq!(imported.run().queues[0].request_id, "r1");
2845 assert_eq!(imported.run().truncation.dropped_requests, 1);
2846 assert_eq!(imported.run().truncation.dropped_stages, 1);
2847 assert_eq!(imported.run().truncation.dropped_queues, 1);
2848 assert!(imported.run().truncation.limits_hit);
2849 assert!(imported.warnings().iter().any(|w| w.message().contains(
2850 "skipped stage span for request_id 'r2' because the matching request was valid but not retained due to max_requests"
2851 )));
2852 assert!(imported.warnings().iter().any(|w| w.message().contains(
2853 "skipped queue span for request_id 'r2' because the matching request was valid but not retained due to max_requests"
2854 )));
2855 assert!(imported.warnings().iter().all(|w| !w
2856 .message()
2857 .contains("no retained request event was imported")));
2858 }
2859
2860 #[test]
2861 fn strict_mode_max_requests_overflow_invalid_stage_still_fails() {
2862 let spans = vec![
2863 SpanRecord::new("req-1", 100, 200)
2864 .field(TT_KIND, "request")
2865 .field(TT_REQUEST_ID, "r1")
2866 .field(TT_ROUTE, "/a"),
2867 SpanRecord::new("req-2", 300, 400)
2868 .field(TT_KIND, "request")
2869 .field(TT_REQUEST_ID, "r2")
2870 .field(TT_ROUTE, "/a"),
2871 SpanRecord::new("st-2", 320, 450)
2872 .field(TT_KIND, "stage")
2873 .field(TT_REQUEST_ID, "r2")
2874 .field(TT_STAGE, "db"),
2875 ];
2876 let err = run_from_span_records(
2877 spans,
2878 ImportOptions::new("checkout")
2879 .strict(true)
2880 .capture_limits_override(tailtriage_core::CaptureLimitsOverride {
2881 max_requests: Some(1),
2882 max_stages: None,
2883 max_queues: None,
2884 ..tailtriage_core::CaptureLimitsOverride::default()
2885 }),
2886 )
2887 .expect_err("strict import should fail for out-of-window overflow stage");
2888 assert!(matches!(err, ImportError::StrictViolation(_)));
2889 let msg = err.to_string();
2890 assert!(msg.contains("falls outside request interval"));
2891 assert!(!msg.contains("valid but not retained due to max_requests"));
2892 }
2893
2894 #[test]
2895 fn strict_mode_max_requests_overflow_invalid_queue_still_fails() {
2896 let spans = vec![
2897 SpanRecord::new("req-1", 100, 200)
2898 .field(TT_KIND, "request")
2899 .field(TT_REQUEST_ID, "r1")
2900 .field(TT_ROUTE, "/a"),
2901 SpanRecord::new("req-2", 300, 400)
2902 .field(TT_KIND, "request")
2903 .field(TT_REQUEST_ID, "r2")
2904 .field(TT_ROUTE, "/a"),
2905 SpanRecord::new("q-2", 320, 450)
2906 .field(TT_KIND, "queue")
2907 .field(TT_REQUEST_ID, "r2")
2908 .field(TT_QUEUE, "permits"),
2909 ];
2910 let err = run_from_span_records(
2911 spans,
2912 ImportOptions::new("checkout")
2913 .strict(true)
2914 .capture_limits_override(tailtriage_core::CaptureLimitsOverride {
2915 max_requests: Some(1),
2916 max_stages: None,
2917 max_queues: None,
2918 ..tailtriage_core::CaptureLimitsOverride::default()
2919 }),
2920 )
2921 .expect_err("strict import should fail for out-of-window overflow queue");
2922 assert!(matches!(err, ImportError::StrictViolation(_)));
2923 let msg = err.to_string();
2924 assert!(msg.contains("falls outside request interval"));
2925 assert!(!msg.contains("valid but not retained due to max_requests"));
2926 }
2927
2928 #[test]
2929 fn strict_mode_max_requests_overflow_non_lexical_request_ids_follow_input_order() {
2930 let spans = vec![
2931 SpanRecord::new("req-1", 100, 200)
2932 .field(TT_KIND, "request")
2933 .field(TT_REQUEST_ID, "z-retained")
2934 .field(TT_ROUTE, "/a"),
2935 SpanRecord::new("st-1", 120, 150)
2936 .field(TT_KIND, "stage")
2937 .field(TT_REQUEST_ID, "z-retained")
2938 .field(TT_STAGE, "db"),
2939 SpanRecord::new("q-1", 121, 130)
2940 .field(TT_KIND, "queue")
2941 .field(TT_REQUEST_ID, "z-retained")
2942 .field(TT_QUEUE, "permits"),
2943 SpanRecord::new("req-2", 300, 400)
2944 .field(TT_KIND, "request")
2945 .field(TT_REQUEST_ID, "a-overflow")
2946 .field(TT_ROUTE, "/a"),
2947 SpanRecord::new("st-2", 320, 350)
2948 .field(TT_KIND, "stage")
2949 .field(TT_REQUEST_ID, "a-overflow")
2950 .field(TT_STAGE, "db"),
2951 SpanRecord::new("q-2", 321, 330)
2952 .field(TT_KIND, "queue")
2953 .field(TT_REQUEST_ID, "a-overflow")
2954 .field(TT_QUEUE, "permits"),
2955 ];
2956 let imported = run_from_span_records(
2957 spans,
2958 ImportOptions::new("checkout")
2959 .strict(true)
2960 .capture_limits_override(tailtriage_core::CaptureLimitsOverride {
2961 max_requests: Some(1),
2962 max_stages: None,
2963 max_queues: None,
2964 ..tailtriage_core::CaptureLimitsOverride::default()
2965 }),
2966 )
2967 .expect("strict import should succeed and retain first input request");
2968 assert_eq!(imported.run().requests.len(), 1);
2969 assert_eq!(imported.run().requests[0].request_id, "z-retained");
2970 assert_eq!(imported.run().stages.len(), 1);
2971 assert_eq!(imported.run().stages[0].request_id, "z-retained");
2972 assert_eq!(imported.run().queues.len(), 1);
2973 assert_eq!(imported.run().queues[0].request_id, "z-retained");
2974 assert_eq!(imported.run().truncation.dropped_requests, 1);
2975 assert_eq!(imported.run().truncation.dropped_stages, 1);
2976 assert_eq!(imported.run().truncation.dropped_queues, 1);
2977 }
2978
2979 #[test]
2980 fn invalid_success_warns_and_skips_stage_non_strict() {
2981 let spans = vec![
2982 SpanRecord::new("req", 10, 20)
2983 .field(TT_KIND, "request")
2984 .field(TT_REQUEST_ID, "r1")
2985 .field(TT_ROUTE, "/")
2986 .field(TT_OUTCOME, "ok"),
2987 SpanRecord::new("st", 1, 1_000)
2988 .field(TT_KIND, "stage")
2989 .field(TT_REQUEST_ID, "r1")
2990 .field(TT_STAGE, "db")
2991 .field(TT_SUCCESS, 7_u64),
2992 ];
2993 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
2994 assert_eq!(imported.run().stages.len(), 0);
2995 assert_eq!(imported.warnings().len(), 1);
2996 assert_eq!(imported.run().metadata.started_at_unix_ms, 10);
2997 assert_eq!(imported.run().metadata.finished_at_unix_ms, 20);
2998 }
2999
3000 #[test]
3001 fn invalid_success_errors_strict() {
3002 let spans = vec![
3003 SpanRecord::new("req", 10, 20)
3004 .field(TT_KIND, "request")
3005 .field(TT_REQUEST_ID, "r1")
3006 .field(TT_ROUTE, "/")
3007 .field(TT_OUTCOME, "ok"),
3008 SpanRecord::new("st", 1, 1_000)
3009 .field(TT_KIND, "stage")
3010 .field(TT_REQUEST_ID, "r1")
3011 .field(TT_STAGE, "db")
3012 .field(TT_SUCCESS, 7_u64),
3013 ];
3014 assert!(run_from_span_records(spans, ImportOptions::new("svc").strict(true)).is_err());
3015 }
3016
3017 #[test]
3018 fn invalid_depth_warns_and_skips_queue_non_strict() {
3019 let spans = vec![
3020 SpanRecord::new("req", 10, 20)
3021 .field(TT_KIND, "request")
3022 .field(TT_REQUEST_ID, "r1")
3023 .field(TT_ROUTE, "/")
3024 .field(TT_OUTCOME, "ok"),
3025 SpanRecord::new("q", 1, 1_000)
3026 .field(TT_KIND, "queue")
3027 .field(TT_REQUEST_ID, "r1")
3028 .field(TT_QUEUE, "permits")
3029 .field(TT_DEPTH_AT_START, -1_i64),
3030 ];
3031 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
3032 assert_eq!(imported.run().queues.len(), 0);
3033 assert_eq!(imported.warnings().len(), 1);
3034 assert_eq!(imported.run().metadata.started_at_unix_ms, 10);
3035 assert_eq!(imported.run().metadata.finished_at_unix_ms, 20);
3036 }
3037
3038 #[test]
3039 fn invalid_depth_errors_strict() {
3040 let spans = vec![
3041 SpanRecord::new("req", 10, 20)
3042 .field(TT_KIND, "request")
3043 .field(TT_REQUEST_ID, "r1")
3044 .field(TT_ROUTE, "/")
3045 .field(TT_OUTCOME, "ok"),
3046 SpanRecord::new("q", 1, 1_000)
3047 .field(TT_KIND, "queue")
3048 .field(TT_REQUEST_ID, "r1")
3049 .field(TT_QUEUE, "permits")
3050 .field(TT_DEPTH_AT_START, 3.5_f64),
3051 ];
3052 assert!(run_from_span_records(spans, ImportOptions::new("svc").strict(true)).is_err());
3053 }
3054
3055 #[test]
3056 fn valid_optional_fields_are_applied() {
3057 let spans = vec![
3058 SpanRecord::new("req", 1, 2)
3059 .field(TT_KIND, "request")
3060 .field(TT_REQUEST_ID, "r1")
3061 .field(TT_ROUTE, "/"),
3062 SpanRecord::new("st", 1, 2)
3063 .field(TT_KIND, "stage")
3064 .field(TT_REQUEST_ID, "r1")
3065 .field(TT_STAGE, "db")
3066 .field(TT_SUCCESS, "false"),
3067 SpanRecord::new("q", 1, 2)
3068 .field(TT_KIND, "queue")
3069 .field(TT_REQUEST_ID, "r1")
3070 .field(TT_QUEUE, "permits")
3071 .field(TT_DEPTH_AT_START, 9_i64),
3072 ];
3073 let run = run_from_span_records(spans, ImportOptions::new("svc"))
3074 .unwrap()
3075 .run()
3076 .clone();
3077 assert!(!run.stages[0].success);
3078 assert_eq!(run.queues[0].depth_at_start, Some(9));
3079 }
3080
3081 #[test]
3082 fn mismatched_request_duration_warns_and_retains_duration_us_in_non_strict_mode() {
3083 let spans = vec![SpanRecord::new("req", 100, 101)
3084 .duration_us(50_000)
3085 .field(TT_KIND, "request")
3086 .field(TT_REQUEST_ID, "r1")
3087 .field(TT_ROUTE, "/a")];
3088 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
3089 assert_eq!(imported.run().requests[0].latency_us, 50_000);
3090 assert!(imported
3091 .warnings()
3092 .iter()
3093 .any(|w| w.message().contains("duration_us was retained")));
3094 assert!(imported.warnings().iter().any(|w| w
3095 .message()
3096 .contains("duration_us differs from timestamp-derived duration")));
3097 assert!(imported.warnings().iter().any(|w| w
3098 .message()
3099 .contains("Unix timestamps remain wall-clock anchors")));
3100 assert!(imported
3101 .run()
3102 .metadata
3103 .lifecycle_warnings
3104 .iter()
3105 .any(|w| w.contains("duration_us was retained")));
3106 }
3107
3108 #[test]
3109 fn absent_request_duration_us_derives_from_timestamps() {
3110 let spans = vec![SpanRecord::new("req", 100, 101)
3111 .field(TT_KIND, "request")
3112 .field(TT_REQUEST_ID, "r1")
3113 .field(TT_ROUTE, "/a")
3114 .field(TT_OUTCOME, "ok")];
3115 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
3116 assert_eq!(imported.run().requests[0].latency_us, 1_000);
3117 assert!(imported.warnings().is_empty());
3118 }
3119
3120 #[test]
3121 fn mismatched_stage_duration_warns_and_retains_duration_us_in_non_strict_mode() {
3122 let spans = vec![
3123 SpanRecord::new("req", 99, 101)
3124 .field(TT_KIND, "request")
3125 .field(TT_REQUEST_ID, "r1")
3126 .field(TT_ROUTE, "/"),
3127 SpanRecord::new("stage", 100, 101)
3128 .duration_us(50_000)
3129 .field(TT_KIND, "stage")
3130 .field(TT_REQUEST_ID, "r1")
3131 .field(TT_STAGE, "db"),
3132 ];
3133 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
3134 assert_eq!(imported.run().stages[0].latency_us, 50_000);
3135 assert!(imported
3136 .warnings()
3137 .iter()
3138 .any(|w| w.message().contains("duration_us was retained")));
3139 }
3140
3141 #[test]
3142 fn mismatched_queue_duration_warns_and_retains_duration_us_in_non_strict_mode() {
3143 let spans = vec![
3144 SpanRecord::new("req", 100, 110)
3145 .field(TT_KIND, "request")
3146 .field(TT_REQUEST_ID, "r1")
3147 .field(TT_ROUTE, "/a"),
3148 SpanRecord::new("q", 101, 102)
3149 .duration_us(50_000)
3150 .field(TT_KIND, "queue")
3151 .field(TT_REQUEST_ID, "r1")
3152 .field(TT_QUEUE, "permits"),
3153 ];
3154 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
3155 assert_eq!(imported.run().queues[0].wait_us, 50_000);
3156 assert!(imported
3157 .warnings()
3158 .iter()
3159 .any(|w| w.message().contains("duration_us was retained")));
3160 }
3161
3162 #[test]
3163 fn strict_mode_rejects_mismatched_request_duration() {
3164 let spans = vec![SpanRecord::new("req", 100, 101)
3165 .duration_us(50_000)
3166 .field(TT_KIND, "request")
3167 .field(TT_REQUEST_ID, "r1")
3168 .field(TT_ROUTE, "/a")];
3169 let err = run_from_span_records(spans, ImportOptions::new("svc").strict(true))
3170 .expect_err("strict import should reject mismatched duration_us");
3171 assert!(matches!(err, ImportError::StrictViolation(_)));
3172 let message = err.to_string();
3173 assert!(message.contains("duration_us differs from timestamp-derived duration"));
3174 assert!(message.contains("strict import rejected the mismatch"));
3175 assert!(!message.contains("duration_us was retained"));
3176 }
3177
3178 #[test]
3179 fn strict_mode_rejects_contradictory_stage_duration() {
3180 let spans = vec![
3181 SpanRecord::new("req", 99, 101)
3182 .field(TT_KIND, "request")
3183 .field(TT_REQUEST_ID, "r1")
3184 .field(TT_ROUTE, "/"),
3185 SpanRecord::new("stage", 100, 101)
3186 .duration_us(50_000)
3187 .field(TT_KIND, "stage")
3188 .field(TT_REQUEST_ID, "r1")
3189 .field(TT_STAGE, "db"),
3190 ];
3191 assert!(matches!(
3192 run_from_span_records(spans, ImportOptions::new("svc").strict(true)),
3193 Err(ImportError::StrictViolation(_))
3194 ));
3195 }
3196
3197 #[test]
3198 fn strict_mode_rejects_contradictory_queue_duration() {
3199 let spans = vec![
3200 SpanRecord::new("req", 100, 110)
3201 .field(TT_KIND, "request")
3202 .field(TT_REQUEST_ID, "r1")
3203 .field(TT_ROUTE, "/a"),
3204 SpanRecord::new("q", 101, 102)
3205 .duration_us(50_000)
3206 .field(TT_KIND, "queue")
3207 .field(TT_REQUEST_ID, "r1")
3208 .field(TT_QUEUE, "permits"),
3209 ];
3210 assert!(matches!(
3211 run_from_span_records(spans, ImportOptions::new("svc").strict(true)),
3212 Err(ImportError::StrictViolation(_))
3213 ));
3214 }
3215
3216 #[test]
3217 fn duration_us_within_2000_microseconds_is_accepted() {
3218 let spans = vec![SpanRecord::new("req", 100, 101)
3219 .duration_us(2_999)
3220 .field(TT_KIND, "request")
3221 .field(TT_REQUEST_ID, "r1")
3222 .field(TT_ROUTE, "/a")];
3223 let imported = run_from_span_records(spans, ImportOptions::new("svc")).unwrap();
3224 assert_eq!(imported.run().requests[0].latency_us, 2_999);
3225 assert!(!imported.warnings().iter().any(|w| w
3226 .message()
3227 .contains("duration_us differs from timestamp-derived duration")));
3228 }
3229
3230 #[test]
3231 fn empty_service_name_is_rejected() {
3232 let err = run_from_span_records(Vec::new(), ImportOptions::new(" ")).unwrap_err();
3233 assert!(matches!(err, ImportError::EmptyServiceName));
3234 }
3235}