manasight_parser/
router.rs

1//! Raw log entry to parser dispatch routing.
2//!
3//! Examines the header prefix and payload of each raw log entry to
4//! determine which category-specific parser should handle it. Unrecognized
5//! entries are counted and logged at debug level.
6//!
7//! # Dispatch strategy
8//!
9//! Each [`LogEntry`] is offered to category parsers in a fixed priority
10//! order (most frequent first). The first parser that returns one or
11//! more events claims the entry. GRE entries may produce multiple
12//! events from batched `GameStateMessage` values. If no parser matches,
13//! the entry is counted as unrecognized and discarded.
14//!
15//! # Timestamp extraction
16//!
17//! The router extracts the timestamp from the entry header line
18//! (e.g., `[UnityCrossThreadLogger]2/25/2026 12:00:00 PM ...`) and
19//! parses it using [`parse_log_timestamp`]. If the timestamp cannot be
20//! parsed, `None` is passed to parsers so downstream consumers can
21//! distinguish real timestamps from missing ones.
22//!
23//! [`LogEntry`]: crate::log::entry::LogEntry
24//! [`parse_log_timestamp`]: crate::log::timestamp::parse_log_timestamp
25
26use std::sync::atomic::{AtomicU64, Ordering};
27
28use chrono::{DateTime, Utc};
29
30use crate::events::GameEvent;
31use crate::log::entry::LogEntry;
32use crate::log::timestamp::parse_log_timestamp;
33use crate::parsers;
34use crate::util::truncate_for_log;
35
36// ---------------------------------------------------------------------------
37// RouterStats
38// ---------------------------------------------------------------------------
39
40/// Counters for router health monitoring.
41///
42/// Tracks the number of entries routed successfully and the number of
43/// unrecognized entries. The unknown-entry count is exposed for upload
44/// health status — a spike after an MTGA update signals that new event
45/// types may need parser support.
46#[derive(Debug, Default)]
47pub struct RouterStats {
48    /// Number of entries successfully routed to a parser.
49    routed: AtomicU64,
50    /// Number of entries not claimed by any parser.
51    unknown: AtomicU64,
52    /// Number of entries where the timestamp could not be parsed.
53    timestamp_failures: AtomicU64,
54}
55
56impl RouterStats {
57    /// Creates a new `RouterStats` with all counters at zero.
58    pub fn new() -> Self {
59        Self::default()
60    }
61
62    /// Returns the number of entries successfully routed to a parser.
63    pub fn routed_count(&self) -> u64 {
64        self.routed.load(Ordering::Relaxed)
65    }
66
67    /// Returns the number of unrecognized entries (not claimed by any parser).
68    pub fn unknown_count(&self) -> u64 {
69        self.unknown.load(Ordering::Relaxed)
70    }
71
72    /// Returns the number of entries where the timestamp could not be parsed.
73    pub fn timestamp_failure_count(&self) -> u64 {
74        self.timestamp_failures.load(Ordering::Relaxed)
75    }
76
77    /// Resets all counters to zero.
78    pub fn reset(&self) {
79        self.routed.store(0, Ordering::Relaxed);
80        self.unknown.store(0, Ordering::Relaxed);
81        self.timestamp_failures.store(0, Ordering::Relaxed);
82    }
83}
84
85// ---------------------------------------------------------------------------
86// Router
87// ---------------------------------------------------------------------------
88
89/// Dispatch router that matches raw log entries to category-specific parsers.
90///
91/// Holds a [`RouterStats`] that tracks routing outcomes for health monitoring.
92/// The router is designed to be long-lived — create one at startup and reuse
93/// it for every entry.
94///
95/// # Example
96///
97/// ```
98/// use manasight_parser::router::Router;
99/// use manasight_parser::log::entry::{LogEntry, EntryHeader};
100///
101/// let router = Router::new();
102///
103/// let entry = LogEntry {
104///     header: EntryHeader::UnityCrossThreadLogger,
105///     body: "[UnityCrossThreadLogger]some unrecognized line".to_owned(),
106/// };
107///
108/// let events = router.route(&entry);
109/// assert!(events.is_empty());
110/// assert_eq!(router.stats().unknown_count(), 1);
111/// ```
112pub struct Router {
113    /// Routing statistics for health monitoring.
114    stats: RouterStats,
115}
116
117impl Router {
118    /// Creates a new router with zeroed statistics.
119    pub fn new() -> Self {
120        Self {
121            stats: RouterStats::new(),
122        }
123    }
124
125    /// Returns a reference to the router's statistics.
126    pub fn stats(&self) -> &RouterStats {
127        &self.stats
128    }
129
130    /// Routes a [`LogEntry`] to the appropriate parser.
131    ///
132    /// Extracts the timestamp from the entry header line, then offers the
133    /// entry to each category parser in priority order. Returns a
134    /// `Vec<GameEvent>` with one or more events if a parser claims the
135    /// entry, or an empty `Vec` if unrecognized.
136    ///
137    /// GRE entries may contain multiple batched `GameStateMessage` values
138    /// in a single log entry, producing multiple events from one entry.
139    ///
140    /// When the timestamp cannot be parsed, `None` is passed to parsers
141    /// so downstream consumers can distinguish real timestamps from
142    /// missing ones. The timestamp failure is counted in [`RouterStats`]
143    /// and logged at debug level.
144    pub fn route(&self, entry: &LogEntry) -> Vec<GameEvent> {
145        let timestamp = extract_timestamp(&entry.body);
146
147        if timestamp.is_none() {
148            self.stats
149                .timestamp_failures
150                .fetch_add(1, Ordering::Relaxed);
151            ::log::debug!(
152                "No timestamp in entry header: {:?}",
153                truncate_for_log(&entry.body, 120),
154            );
155        }
156
157        let events = dispatch_to_parsers(entry, timestamp);
158
159        if events.is_empty() {
160            self.stats.unknown.fetch_add(1, Ordering::Relaxed);
161            ::log::debug!(
162                "Unrecognized entry (header={}, body={:?})",
163                entry.header,
164                truncate_for_log(&entry.body, 120),
165            );
166        } else {
167            self.stats.routed.fetch_add(1, Ordering::Relaxed);
168        }
169
170        events
171    }
172}
173
174impl Default for Router {
175    fn default() -> Self {
176        Self::new()
177    }
178}
179
180// ---------------------------------------------------------------------------
181// Internal helpers
182// ---------------------------------------------------------------------------
183
184/// Extracts and parses the timestamp from the first line of an entry body.
185///
186/// The expected format is:
187/// ```text
188/// [UnityCrossThreadLogger]2/25/2026 12:00:00 PM some content
189/// [UnityCrossThreadLogger]3/13/2026 11:34:51 PM: Match to ...
190/// ```
191///
192/// Strips the bracket-enclosed header prefix and extracts the date/time
193/// portion that follows. The timestamp string may be followed by
194/// additional content on the same line (event name, method name, etc.)
195/// or by a newline if the timestamp is on its own line.
196///
197/// Trims trailing punctuation (like colons in `... PM: MatchGameRoom...`) from
198/// the extracted tokens before parsing to ensure robust matching.
199fn extract_timestamp(body: &str) -> Option<DateTime<Utc>> {
200    let first_line = body.lines().next()?;
201
202    // Strip the header prefix: find the closing `]` bracket.
203    let after_bracket = first_line.find(']').map(|pos| &first_line[pos + 1..])?;
204    let trimmed = after_bracket.trim();
205
206    if trimmed.is_empty() {
207        return None;
208    }
209
210    // The timestamp may be followed by additional text (event name, etc.).
211    // Try progressively shorter prefixes to find a valid timestamp.
212    // Start with the full string and remove trailing words one at a time.
213    let words: Vec<&str> = trimmed.split_whitespace().collect();
214
215    // Timestamps typically use 2-3 tokens (date + time, or date + time + AM/PM).
216    // Try from longest plausible prefix down to 2 tokens.
217    let max_words = words.len().min(4);
218    for end in (2..=max_words).rev() {
219        let candidate = words[..end].join(" ");
220        // Ensure trailing punctuation (like colons after AM/PM) doesn't break parsing.
221        let cleaned = candidate.trim_end_matches(|c: char| c.is_ascii_punctuation());
222        if let Ok(ts) = parse_log_timestamp(cleaned) {
223            return Some(ts);
224        }
225    }
226
227    None
228}
229
230/// Dispatches a log entry to category parsers in priority order.
231///
232/// Parsers are tried in order of expected frequency during typical
233/// gameplay to minimize unnecessary parse attempts:
234///
235/// 0. Metadata — `DETAILED LOGS` status (header-type short-circuit)
236/// 1. GRE messages (game state + game result) — most frequent in-game
237/// 2. Client actions — frequent player decisions
238/// 3. Match state — match boundaries
239/// 4. Session — login/logout
240/// 5. Draft bot — bot draft picks
241/// 6. Draft human — human draft picks
242/// 7. Draft complete — draft completion
243/// 8. Event lifecycle — event joins/claims
244/// 9. Rank — rank snapshots
245/// 10. Deck collection — deck snapshots from `StartHook`
246/// 11. Inventory — inventory from `StartHook`
247/// 12. Match connection state — `STATE CHANGED` transitions
248/// 13. Connection close — `Client.TcpConnection.Close` / `GREConnection.HandleWebSocketClosed`
249///
250/// The GRE parser may return multiple events from a single entry
251/// (batched `GameStateMessage` values). All other parsers return at
252/// most one event.
253///
254/// `timestamp` is `None` when the log entry header did not contain a
255/// parseable timestamp; parsers pass it through to `EventMetadata`.
256fn dispatch_to_parsers(entry: &LogEntry, timestamp: Option<DateTime<Utc>>) -> Vec<GameEvent> {
257    // Metadata entries are routed directly to the metadata parser.
258    if let Some(event) = parsers::metadata::try_parse(entry, timestamp) {
259        return vec![event];
260    }
261
262    // Truncation marker entries — structurally a metadata-style entry (no
263    // JSON body, header-only data) so dispatched alongside metadata before
264    // the GRE path. The parser gates on `EntryHeader::TruncationMarker`, so
265    // non-truncation entries pass straight through.
266    if let Some(event) = parsers::truncation::try_parse(entry, timestamp) {
267        return vec![event];
268    }
269
270    // GRE parser returns Vec<GameEvent> (may contain multiple batched GSMs).
271    let gre_events = parsers::gre::try_parse(entry, timestamp);
272    if !gre_events.is_empty() {
273        return gre_events;
274    }
275
276    // All other parsers return Option<GameEvent> (at most one event per entry).
277    let event = None
278        .or_else(|| parsers::client_actions::try_parse(entry, timestamp))
279        .or_else(|| parsers::match_state::try_parse(entry, timestamp))
280        .or_else(|| parsers::session::try_parse(entry, timestamp))
281        .or_else(|| parsers::draft::bot::try_parse(entry, timestamp))
282        .or_else(|| parsers::draft::human::try_parse(entry, timestamp))
283        .or_else(|| parsers::draft::complete::try_parse(entry, timestamp))
284        .or_else(|| parsers::event_lifecycle::try_parse(entry, timestamp))
285        .or_else(|| parsers::rank::try_parse(entry, timestamp))
286        .or_else(|| parsers::deck_collection::try_parse(entry, timestamp))
287        .or_else(|| parsers::inventory::try_parse(entry, timestamp))
288        .or_else(|| parsers::connection_state::try_parse(entry, timestamp))
289        .or_else(|| parsers::connection_close::try_parse(entry, timestamp))
290        .or_else(|| parsers::connection_error::try_parse(entry, timestamp));
291
292    event.into_iter().collect()
293}
294
295// ---------------------------------------------------------------------------
296// Tests
297// ---------------------------------------------------------------------------
298
299#[cfg(test)]
300mod tests {
301    use super::*;
302    use crate::log::entry::EntryHeader;
303    use chrono::Timelike;
304
305    /// Helper: build a `LogEntry` with `UnityCrossThreadLogger` header.
306    fn unity_entry(body: &str) -> LogEntry {
307        LogEntry {
308            header: EntryHeader::UnityCrossThreadLogger,
309            body: body.to_owned(),
310        }
311    }
312
313    // -- extract_timestamp ---------------------------------------------------
314
315    mod extract_timestamp_tests {
316        use super::*;
317
318        #[test]
319        fn test_extract_timestamp_us_format_with_pm() {
320            let body = "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM greToClientEvent";
321            let ts = extract_timestamp(body);
322            assert!(ts.is_some());
323            if let Some(ts) = ts {
324                assert_eq!(
325                    ts.format("%Y-%m-%d %H:%M:%S").to_string(),
326                    "2026-02-25 12:00:00"
327                );
328            }
329        }
330
331        #[test]
332        fn test_extract_timestamp_us_format_with_am() {
333            let body = "[UnityCrossThreadLogger]2/22/2026 11:59:51 AM";
334            let ts = extract_timestamp(body);
335            assert!(ts.is_some());
336            if let Some(ts) = ts {
337                assert_eq!(
338                    ts.format("%Y-%m-%d %H:%M:%S").to_string(),
339                    "2026-02-22 11:59:51"
340                );
341            }
342        }
343
344        #[test]
345        fn test_extract_timestamp_with_trailing_colon() {
346            let body = "[UnityCrossThreadLogger]3/13/2026 11:34:51 PM: Match to AAF4FC69CE47D53A";
347            let ts = extract_timestamp(body);
348            assert!(ts.is_some());
349            if let Some(ts) = ts {
350                assert_eq!(ts.hour(), 23); // Should correctly identify PM
351            }
352        }
353
354        #[test]
355        fn test_extract_timestamp_24h_format() {
356            let body = "[UnityCrossThreadLogger]2026-02-25 14:30:00 some content";
357            let ts = extract_timestamp(body);
358            assert!(ts.is_some());
359            if let Some(ts) = ts {
360                assert_eq!(
361                    ts.format("%Y-%m-%d %H:%M:%S").to_string(),
362                    "2026-02-25 14:30:00"
363                );
364            }
365        }
366
367        #[test]
368        fn test_extract_timestamp_no_bracket_returns_none() {
369            let body = "no bracket here";
370            let ts = extract_timestamp(body);
371            assert!(ts.is_none());
372        }
373
374        #[test]
375        fn test_extract_timestamp_empty_after_bracket_returns_none() {
376            let body = "[UnityCrossThreadLogger]";
377            let ts = extract_timestamp(body);
378            assert!(ts.is_none());
379        }
380
381        #[test]
382        fn test_extract_timestamp_no_timestamp_content_returns_none() {
383            let body = "[UnityCrossThreadLogger]FrontDoorConnection.Close";
384            let ts = extract_timestamp(body);
385            assert!(ts.is_none());
386        }
387
388        #[test]
389        fn test_extract_timestamp_timestamp_on_own_line() {
390            let body = "[UnityCrossThreadLogger]2/22/2026 11:59:51 AM\n<== StartHook(abc-123)";
391            let ts = extract_timestamp(body);
392            assert!(ts.is_some());
393            if let Some(ts) = ts {
394                assert_eq!(
395                    ts.format("%Y-%m-%d %H:%M:%S").to_string(),
396                    "2026-02-22 11:59:51"
397                );
398            }
399        }
400
401        #[test]
402        fn test_extract_timestamp_with_leading_space() {
403            let body = "[UnityCrossThreadLogger] 2/25/2026 12:00:00 PM event";
404            let ts = extract_timestamp(body);
405            assert!(ts.is_some());
406        }
407    }
408
409    // -- Router: known entry routing -----------------------------------------
410
411    mod known_routing {
412        use super::*;
413
414        #[test]
415        fn test_route_gre_game_state_message() {
416            let router = Router::new();
417            let payload = serde_json::json!({
418                "greToClientEvent": {
419                    "greToClientMessages": [{
420                        "type": "GREMessageType_GameStateMessage",
421                        "gameStateMessage": {
422                            "gameInfo": { "stage": "GameStage_Play" },
423                            "gameObjects": [],
424                            "zones": []
425                        }
426                    }]
427                }
428            });
429            let body = format!("[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n{payload}");
430            let entry = unity_entry(&body);
431
432            let results = router.route(&entry);
433            assert_eq!(results.len(), 1);
434            assert!(matches!(&results[0], GameEvent::GameState(_)));
435            assert_eq!(router.stats().routed_count(), 1);
436            assert_eq!(router.stats().unknown_count(), 0);
437        }
438
439        #[test]
440        fn test_route_client_action() {
441            let router = Router::new();
442            let payload = serde_json::json!({
443                "clientToMatchServiceMessageType":
444                    "ClientToMatchServiceMessageType_ClientToGREMessage",
445                "payload": {
446                    "type": "ClientMessageType_MulliganResp",
447                    "gameStateId": 5,
448                    "respId": 1,
449                    "mulliganResp": { "decision": "MulliganOption_Mulligan" }
450                },
451                "requestId": 12345,
452                "timestamp": "637123456789"
453            });
454            let body = format!("[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n{payload}");
455            let entry = unity_entry(&body);
456
457            let results = router.route(&entry);
458            assert_eq!(results.len(), 1);
459            assert!(matches!(&results[0], GameEvent::ClientAction(_)));
460        }
461
462        #[test]
463        fn test_route_match_state() {
464            let router = Router::new();
465            let payload = serde_json::json!({
466                "matchGameRoomStateChangedEvent": {
467                    "gameRoomInfo": {
468                        "stateType": "MatchGameRoomStateType_Playing",
469                        "gameRoomConfig": {
470                            "matchId": "match-123",
471                            "reservedPlayers": []
472                        }
473                    }
474                }
475            });
476            let body = format!("[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n{payload}");
477            let entry = unity_entry(&body);
478
479            let results = router.route(&entry);
480            assert_eq!(results.len(), 1);
481            assert!(matches!(&results[0], GameEvent::MatchState(_)));
482        }
483
484        #[test]
485        fn test_route_session_authenticate_response() {
486            let router = Router::new();
487            let body = "[UnityCrossThreadLogger]authenticateResponse\n\
488                         {\"screenName\":\"TestPlayer\"}";
489            let entry = unity_entry(body);
490
491            let results = router.route(&entry);
492            assert_eq!(results.len(), 1);
493            assert!(matches!(&results[0], GameEvent::Session(_)));
494        }
495
496        #[test]
497        fn test_route_rank_event() {
498            let router = Router::new();
499            let payload = serde_json::json!({
500                "constructedClass": "Gold",
501                "constructedLevel": 2,
502                "limitedClass": "Silver",
503                "limitedLevel": 1
504            });
505            let body = format!(
506                "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n\
507                 <== RankGetCombinedRankInfo(abc-123)\n{payload}",
508            );
509            let entry = unity_entry(&body);
510
511            let results = router.route(&entry);
512            assert_eq!(results.len(), 1);
513            assert!(matches!(&results[0], GameEvent::Rank(_)));
514        }
515
516        #[test]
517        fn test_route_event_lifecycle() {
518            let router = Router::new();
519            let body = "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM \
520                         ==> EventJoin {\"id\":\"abc-123\",\
521                         \"request\":\"{\\\"EventName\\\":\\\"PremierDraft_MKM\\\"}\"}";
522            let entry = unity_entry(body);
523
524            let results = router.route(&entry);
525            assert_eq!(results.len(), 1);
526            assert!(matches!(&results[0], GameEvent::EventLifecycle(_)));
527        }
528
529        #[test]
530        fn test_route_draft_complete() {
531            let router = Router::new();
532            let payload = serde_json::json!({
533                "CourseId": "draft-123",
534                "InternalEventName": "PremierDraft_MKM",
535                "CardPool": [12345, 67890]
536            });
537            let body = format!(
538                "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n\
539                 <== DraftCompleteDraft(abc-123)\n{payload}",
540            );
541            let entry = unity_entry(&body);
542
543            let results = router.route(&entry);
544            assert_eq!(results.len(), 1);
545            assert!(matches!(&results[0], GameEvent::DraftComplete(_)));
546        }
547
548        #[test]
549        fn test_route_draft_bot_pack_presentation() {
550            let router = Router::new();
551            let payload = serde_json::json!({
552                "CurrentModule": "BotDraft",
553                "Payload":"{\"DraftStatus\":\"PickNext\",\"PackNumber\":0,\"PickNumber\":0,\"DraftPack\":[\"12345\",\"67890\",\"11111\"]}"
554            });
555            let body = format!("[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n<== BotDraftDraftStatus(uuid)\n{payload}",);
556            let entry = unity_entry(&body);
557
558            let results = router.route(&entry);
559            assert_eq!(results.len(), 1);
560            assert!(matches!(&results[0], GameEvent::DraftBot(_)));
561        }
562
563        #[test]
564        fn test_route_draft_human_notify() {
565            let router = Router::new();
566            let payload = serde_json::json!({
567                "draftId": "abc-123-def",
568                "SelfPack": 0,
569                "SelfPick": 0,
570                "PackCards": "12345,67890,11111"
571            });
572            let body = format!("[UnityCrossThreadLogger]Draft.Notify\n{payload}",);
573            let entry = unity_entry(&body);
574
575            let results = router.route(&entry);
576            assert_eq!(results.len(), 1);
577            assert!(matches!(&results[0], GameEvent::DraftHuman(_)));
578        }
579
580        #[test]
581        fn test_route_start_hook_with_additional_fields_routes_to_inventory() {
582            let router = Router::new();
583            let payload = serde_json::json!({
584                "InventoryInfo": { "Gems": 100 },
585                "DeckSummariesV2": []
586            });
587            let body = format!(
588                "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n\
589                 <== StartHook(abc-123)\n{payload}",
590            );
591            let entry = unity_entry(&body);
592
593            let results = router.route(&entry);
594            assert_eq!(results.len(), 1);
595            assert!(matches!(&results[0], GameEvent::Inventory(_)));
596        }
597
598        #[test]
599        fn test_route_inventory_event() {
600            let router = Router::new();
601            let payload = serde_json::json!({
602                "InventoryInfo": { "Gems": 100, "Gold": 5000 }
603            });
604            let body = format!(
605                "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n\
606                 <== StartHook(abc-123)\n{payload}",
607            );
608            let entry = unity_entry(&body);
609
610            let results = router.route(&entry);
611            assert_eq!(results.len(), 1);
612            assert!(matches!(&results[0], GameEvent::Inventory(_)));
613        }
614    }
615
616    // -- Router: unknown entry handling --------------------------------------
617
618    mod unknown_entries {
619        use super::*;
620
621        #[test]
622        fn test_route_unknown_entry_returns_empty() {
623            let router = Router::new();
624            let body = "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n\
625                         some unrecognized content here";
626            let entry = unity_entry(body);
627
628            let results = router.route(&entry);
629            assert!(results.is_empty());
630        }
631
632        #[test]
633        fn test_route_unknown_entry_increments_counter() {
634            let router = Router::new();
635            let body = "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n\
636                         unrecognized content";
637            let entry = unity_entry(body);
638
639            router.route(&entry);
640            assert_eq!(router.stats().unknown_count(), 1);
641            assert_eq!(router.stats().routed_count(), 0);
642        }
643
644        #[test]
645        fn test_route_multiple_unknown_entries_accumulates() {
646            let router = Router::new();
647
648            for i in 0..5 {
649                let body = format!("[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\nunknown_{i}",);
650                let entry = unity_entry(&body);
651                router.route(&entry);
652            }
653
654            assert_eq!(router.stats().unknown_count(), 5);
655            assert_eq!(router.stats().routed_count(), 0);
656        }
657
658        #[test]
659        fn test_route_empty_body_after_header_returns_empty() {
660            let router = Router::new();
661            let body = "[UnityCrossThreadLogger]";
662            let entry = unity_entry(body);
663
664            let results = router.route(&entry);
665            // No timestamp -> passes None, but no parser matches.
666            assert!(results.is_empty());
667            assert_eq!(router.stats().timestamp_failure_count(), 1);
668            assert_eq!(router.stats().unknown_count(), 1);
669        }
670
671        #[test]
672        fn test_route_no_timestamp_increments_timestamp_failure() {
673            let router = Router::new();
674            let body = "[UnityCrossThreadLogger]just some text without a timestamp";
675            let entry = unity_entry(body);
676
677            let results = router.route(&entry);
678            // No parseable timestamp and no parser claims this entry.
679            assert!(results.is_empty());
680            assert_eq!(router.stats().timestamp_failure_count(), 1);
681            assert_eq!(router.stats().unknown_count(), 1);
682        }
683
684        #[test]
685        fn test_route_no_timestamp_session_still_routes() {
686            let router = Router::new();
687            // Real-world session entries without timestamps should still route.
688            let body = "[UnityCrossThreadLogger]authenticateResponse\n\
689                         {\"screenName\":\"Player\"}";
690            let entry = unity_entry(body);
691
692            let results = router.route(&entry);
693            assert_eq!(results.len(), 1);
694            // Session routed even without a timestamp in header.
695            assert!(matches!(&results[0], GameEvent::Session(_)));
696            assert_eq!(router.stats().timestamp_failure_count(), 1);
697            assert_eq!(router.stats().routed_count(), 1);
698        }
699
700        #[test]
701        fn test_route_no_timestamp_passes_none_to_metadata() {
702            let router = Router::new();
703            // Session entries without timestamps should have None timestamp
704            // in metadata rather than a synthetic Utc::now().
705            let body = "[UnityCrossThreadLogger]authenticateResponse\n\
706                         {\"screenName\":\"Player\"}";
707            let entry = unity_entry(body);
708
709            let results = router.route(&entry);
710            assert_eq!(results.len(), 1);
711            assert!(
712                results[0].metadata().timestamp().is_none(),
713                "entries without parseable timestamps should have None timestamp"
714            );
715        }
716
717        #[test]
718        fn test_route_with_timestamp_passes_some_to_metadata() {
719            let router = Router::new();
720            let payload = serde_json::json!({
721                "greToClientEvent": {
722                    "greToClientMessages": [{
723                        "type": "GREMessageType_GameStateMessage",
724                        "gameStateMessage": {
725                            "gameInfo": { "stage": "GameStage_Play" },
726                            "gameObjects": [],
727                            "zones": []
728                        }
729                    }]
730                }
731            });
732            let body = format!("[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\n{payload}");
733            let entry = unity_entry(&body);
734
735            let results = router.route(&entry);
736            assert_eq!(results.len(), 1);
737            assert!(
738                results[0].metadata().timestamp().is_some(),
739                "entries with parseable timestamps should have Some timestamp"
740            );
741        }
742    }
743
744    // -- Router: statistics --------------------------------------------------
745
746    mod stats {
747        use super::*;
748
749        #[test]
750        fn test_stats_initial_values_are_zero() {
751            let router = Router::new();
752            assert_eq!(router.stats().routed_count(), 0);
753            assert_eq!(router.stats().unknown_count(), 0);
754            assert_eq!(router.stats().timestamp_failure_count(), 0);
755        }
756
757        #[test]
758        fn test_stats_reset_clears_all_counters() {
759            let router = Router::new();
760
761            // Route a few entries to increment counters.
762            let body = "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\nunknown";
763            let entry = unity_entry(body);
764            router.route(&entry);
765            router.route(&entry);
766
767            assert_eq!(router.stats().unknown_count(), 2);
768
769            router.stats().reset();
770
771            assert_eq!(router.stats().routed_count(), 0);
772            assert_eq!(router.stats().unknown_count(), 0);
773            assert_eq!(router.stats().timestamp_failure_count(), 0);
774        }
775
776        #[test]
777        fn test_stats_mixed_routing() {
778            let router = Router::new();
779
780            // Route one known entry (session -- no timestamp in header).
781            let known_body = "[UnityCrossThreadLogger]authenticateResponse\n\
782                              {\"screenName\":\"Player\"}";
783            router.route(&unity_entry(known_body));
784
785            // Route one unknown entry (with valid timestamp).
786            let unknown_body = "[UnityCrossThreadLogger]2/25/2026 12:00:00 PM\nunknown";
787            router.route(&unity_entry(unknown_body));
788
789            // Route one entry with no timestamp and no parser match.
790            let bad_ts_body = "[UnityCrossThreadLogger]";
791            router.route(&unity_entry(bad_ts_body));
792
793            assert_eq!(router.stats().routed_count(), 1);
794            // Two unknown: one with valid timestamp, one with timestamp failure.
795            assert_eq!(router.stats().unknown_count(), 2);
796            // Two timestamp failures: the session entry and the empty entry.
797            assert_eq!(router.stats().timestamp_failure_count(), 2);
798        }
799    }
800
801    // -- Router: default impl -----------------------------------------------
802
803    mod default_impl {
804        use super::*;
805
806        #[test]
807        fn test_router_default_creates_functional_router() {
808            let router = Router::default();
809            assert_eq!(router.stats().routed_count(), 0);
810            assert_eq!(router.stats().unknown_count(), 0);
811        }
812    }
813
814    // -- Router: Metadata header entries --------------------------------------
815
816    mod metadata_entries {
817        use super::*;
818
819        /// Helper: build a `LogEntry` with `Metadata` header.
820        fn metadata_entry(body: &str) -> LogEntry {
821            LogEntry {
822                header: EntryHeader::Metadata,
823                body: body.to_owned(),
824            }
825        }
826
827        #[test]
828        fn test_route_detailed_logs_enabled() {
829            let router = Router::new();
830            let entry = metadata_entry("DETAILED LOGS: ENABLED");
831
832            let results = router.route(&entry);
833            assert_eq!(results.len(), 1);
834            assert!(matches!(&results[0], GameEvent::DetailedLoggingStatus(_)));
835            if let GameEvent::DetailedLoggingStatus(ref e) = results[0] {
836                assert_eq!(e.enabled(), Some(true));
837            }
838            assert_eq!(router.stats().routed_count(), 1);
839        }
840
841        #[test]
842        fn test_route_detailed_logs_disabled() {
843            let router = Router::new();
844            let entry = metadata_entry("DETAILED LOGS: DISABLED");
845
846            let results = router.route(&entry);
847            assert_eq!(results.len(), 1);
848            assert!(matches!(&results[0], GameEvent::DetailedLoggingStatus(_)));
849            if let GameEvent::DetailedLoggingStatus(ref e) = results[0] {
850                assert_eq!(e.enabled(), Some(false));
851            }
852        }
853
854        #[test]
855        fn test_route_metadata_no_timestamp_failure() {
856            let router = Router::new();
857            let entry = metadata_entry("DETAILED LOGS: ENABLED");
858
859            router.route(&entry);
860            // Metadata entries have no bracket prefix for timestamp extraction,
861            // so they increment the timestamp failure counter.
862            assert_eq!(router.stats().timestamp_failure_count(), 1);
863            // But they should still be routed successfully.
864            assert_eq!(router.stats().routed_count(), 1);
865        }
866
867        #[test]
868        fn test_route_unrecognized_metadata_returns_empty() {
869            let router = Router::new();
870            let entry = metadata_entry("SOME OTHER METADATA");
871
872            let results = router.route(&entry);
873            assert!(results.is_empty());
874            assert_eq!(router.stats().unknown_count(), 1);
875        }
876    }
877
878    // -- Router: GSM truncation marker entries (#200) ------------------------
879
880    mod truncation_marker_entries {
881        use super::*;
882
883        fn truncation_entry(body: &str) -> LogEntry {
884            LogEntry {
885                header: EntryHeader::TruncationMarker,
886                body: body.to_owned(),
887            }
888        }
889
890        fn marker_body(object_count: u32, annotation_count: u32) -> String {
891            format!(
892                "[Message summarized because one or more GameStateMessages \
893                 exceeded the 50 GameObject or 50 Annotation limit.]\n\
894                 ::: GameStateMessage\n\
895                 :: GameObject Count = {object_count}\n\
896                 :: Annotation Count = {annotation_count}\n\
897                 ::: ActionsAvailableReq"
898            )
899        }
900
901        #[test]
902        fn test_route_truncation_marker_emits_truncation_event() {
903            let router = Router::new();
904            let entry = truncation_entry(&marker_body(63, 4));
905
906            let results = router.route(&entry);
907            assert_eq!(results.len(), 1);
908            assert!(matches!(&results[0], GameEvent::Truncation(_)));
909            assert_eq!(router.stats().routed_count(), 1);
910            assert_eq!(router.stats().unknown_count(), 0);
911        }
912
913        #[test]
914        fn test_route_truncation_marker_preserves_counts() {
915            let router = Router::new();
916            let entry = truncation_entry(&marker_body(63, 4));
917
918            let results = router.route(&entry);
919            assert_eq!(results.len(), 1);
920            let GameEvent::Truncation(ref event) = results[0] else {
921                unreachable!("expected Truncation event");
922            };
923            assert_eq!(event.object_count(), Some(63));
924            assert_eq!(event.annotation_count(), Some(4));
925        }
926
927        #[test]
928        fn test_route_truncation_marker_without_counts_is_unrecognized() {
929            // Marker header but no count lines — the parser bails and the
930            // router falls through to its unknown-counter path.
931            let router = Router::new();
932            let body = "[Message summarized because one or more GameStateMessages \
933                        exceeded the 50 GameObject or 50 Annotation limit.]";
934            let entry = truncation_entry(body);
935
936            let results = router.route(&entry);
937            assert!(results.is_empty());
938            assert_eq!(router.stats().unknown_count(), 1);
939        }
940    }
941}
manasight_parser/router.rs

manasight_parser/
router.rs
