Skip to main content

tailtriage_tracing/
lib.rs

1#![doc = include_str!("../README.md")]
2#![warn(missing_docs)]
3
4//! Tracing intake bridge types for tailtriage triage workflows.
5//!
6//! This crate provides semantic `tt.*` keys, typed [`SpanRecord`] intake,
7//! and conversion to [`tailtriage_core::Run`] via [`run_from_span_records`].
8//! The `jsonl` feature adds JSONL import APIs.
9//! The `live` feature adds live in-memory recording APIs.
10//! It does not implement OpenTelemetry/OTLP. It converts tracing evidence into
11//! standard `tailtriage_core::Run` artifacts and does not introduce a
12//! tracing-specific analyzer path; Run JSON and the existing analyzer remain the
13//! center of the workflow.
14//!
15//! # Example
16//!
17//! ```
18//! use tailtriage_tracing::{
19//!     ImportOptions, SpanRecord, TT_KIND, TT_OUTCOME, TT_REQUEST_ID, TT_ROUTE,
20//! };
21//!
22//! let record = SpanRecord::new("http.request", 1_700_000_000_000, 1_700_000_000_120)
23//!     .field(TT_KIND, "request")
24//!     .field(TT_REQUEST_ID, "req-42")
25//!     .field(TT_ROUTE, "/checkout")
26//!     .field(TT_OUTCOME, "ok");
27//!
28//! let options = ImportOptions::new("checkout-service").strict(false);
29//! assert_eq!(record.name(), "http.request");
30//! assert_eq!(options.service_name(), "checkout-service");
31//! ```
32
33mod convention;
34mod error;
35#[cfg(feature = "jsonl")]
36mod jsonl;
37#[cfg(feature = "live")]
38mod recorder;
39#[cfg(feature = "tokio")]
40/// Optional Tokio runtime sampler coupling for tracing sessions.
41pub 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
66/// Ensures a run is suitable for persisted Run JSON artifacts intended for CLI analysis.
67///
68/// # Errors
69///
70/// Returns [`ImportError::ZeroRequestArtifact`] when the run has no completed request events.
71pub 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/// Converts in-memory tracing span records into a `tailtriage_core::Run`.
107///
108/// Spans without any `tt.*` fields are ignored silently. Spans with `tt.*`
109/// fields but missing `tt.kind` are treated as malformed tailtriage input.
110/// In non-strict mode, malformed `tt.*` spans are skipped and surfaced as
111/// warnings. In strict mode, the first malformed `tt.*` span returns an
112/// [`ImportError`].
113/// # Errors
114///
115/// Returns [`ImportError::StrictViolation`] when `options.strict(true)` is set
116/// and a tailtriage-tagged span is malformed or incomplete.
117#[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}