async Task RunForSymRTC(
            IEnumerableAsync <Sym.Message[]> messages,
            LogSourcePostprocessorInput postprocessorInput
            )
        {
            IPrefixMatcher matcher     = postprocessing.CreatePrefixMatcher();
            var            logMessages = messages.MatchTextPrefixes(matcher).Multiplex();

            Sym.IMeetingsStateInspector symMeetingsStateInspector = new Sym.MeetingsStateInspector(matcher);
            Sym.IMediaStateInspector    symMediaStateInspector    = new Sym.MediaStateInspector(matcher, symMeetingsStateInspector);

            var symMeetingEvents = symMeetingsStateInspector.GetEvents(logMessages);
            var symMediagEvents  = symMediaStateInspector.GetEvents(logMessages);

            matcher.Freeze();

            var events = postprocessorInput.TemplatesTracker.TrackTemplates(EnumerableAsync.Merge(
                                                                                symMeetingEvents,
                                                                                symMediagEvents
                                                                                ));

            var serialize = postprocessing.StateInspector.SavePostprocessorOutput(
                events,
                null,
                evtTrigger => TextLogEventTrigger.Make((Sym.Message)evtTrigger),
                postprocessorInput
                );

            await Task.WhenAll(serialize, logMessages.Open());
        }
        private IEnumerableAsync <Event[]> RunForSymMessages(
            IPrefixMatcher matcher,
            IEnumerableAsync <Sym.Message[]> messages,
            ICodepathTracker templatesTracker,
            out IMultiplexingEnumerable <MessagePrefixesPair <Sym.Message>[]> symLog
            )
        {
            Sym.IMeetingsStateInspector symMeetingsStateInspector = new Sym.MeetingsStateInspector(matcher);
            Sym.IMediaStateInspector    symMediaStateInsector     = new Sym.MediaStateInspector(matcher, symMeetingsStateInspector);
            Sym.ITimelineEvents         symTimelineEvents         = new Sym.TimelineEvents(matcher);
            Sym.Diag.ITimelineEvents    diagTimelineEvents        = new Sym.Diag.TimelineEvents(matcher);

            symLog = messages.MatchTextPrefixes(matcher).Multiplex();
            var symMeetingStateEvents = symMeetingsStateInspector.GetEvents(symLog);
            var symMediaStateEvents   = symMediaStateInsector.GetEvents(symLog);

            var symMeetingEvents = postprocessing.Timeline.CreateInspectedObjectsLifetimeEventsSource(e =>
                                                                                                      e.ObjectType == Sym.MeetingsStateInspector.MeetingTypeInfo ||
                                                                                                      e.ObjectType == Sym.MeetingsStateInspector.MeetingSessionTypeInfo ||
                                                                                                      e.ObjectType == Sym.MeetingsStateInspector.MeetingRemoteParticipantTypeInfo ||
                                                                                                      e.ObjectType == Sym.MeetingsStateInspector.ProbeSessionTypeInfo ||
                                                                                                      e.ObjectType == Sym.MeetingsStateInspector.InvitationTypeInfo
                                                                                                      ).GetEvents(symMeetingStateEvents);

            var symMediaEvents = postprocessing.Timeline.CreateInspectedObjectsLifetimeEventsSource(e =>
                                                                                                    e.ObjectType == Sym.MediaStateInspector.LocalScreenTypeInfo ||
                                                                                                    e.ObjectType == Sym.MediaStateInspector.LocalAudioTypeInfo ||
                                                                                                    e.ObjectType == Sym.MediaStateInspector.LocalVideoTypeInfo ||
                                                                                                    e.ObjectType == Sym.MediaStateInspector.TestSessionTypeInfo
                                                                                                    ).GetEvents(symMediaStateEvents);

            var events = templatesTracker.TrackTemplates(EnumerableAsync.Merge(
                                                             symMeetingEvents,
                                                             symMediaEvents,
                                                             symTimelineEvents.GetEvents(symLog),
                                                             diagTimelineEvents.GetEvents(symLog)
                                                             ));

            return(events);
        }
        async Task RunForChromeDriver(
            IEnumerableAsync <CD.Message[]> input,
            LogSourcePostprocessorInput postprocessorInput
            )
        {
            IPrefixMatcher matcher     = postprocessing.CreatePrefixMatcher();
            var            logMessages = input.MatchTextPrefixes(matcher).Multiplex();

            CD.ITimelineEvents networkEvents = new CD.TimelineEvents(matcher);
            var endOfTimelineEventSource     = postprocessing.Timeline.CreateEndOfTimelineEventSource <MessagePrefixesPair <CD.Message> > (m => m.Message);

            var extensionSources = pluginModel.ChromeDriverTimeLineEventSources.Select(src => src(
                                                                                           matcher, logMessages, postprocessorInput.TemplatesTracker)).ToArray();

            var networkEvts = networkEvents.GetEvents(logMessages);
            var eofEvts     = endOfTimelineEventSource.GetEvents(logMessages);

            matcher.Freeze();

            var events = extensionSources.Select(s => s.Events).ToList();

            events.Add(networkEvts);
            events.Add(eofEvts);

            var serialize = postprocessing.Timeline.SavePostprocessorOutput(
                EnumerableAsync.Merge(events.ToArray()),
                null,
                evtTrigger => TextLogEventTrigger.Make((CD.Message)evtTrigger),
                postprocessorInput
                );

            var tasks = new List <Task>();

            tasks.Add(serialize);
            tasks.AddRange(extensionSources.SelectMany(s => s.MultiplexingEnumerables.Select(e => e.Open())));
            tasks.Add(logMessages.Open());

            await Task.WhenAll(tasks);
        }