public IEnumerableAsync <Timeline.Event[]> GetEvents(IEnumerableAsync <StateInspector.Event[]> input) { return(input.Select <StateInspector.Event, Timeline.Event>((evt, buffer) => { resultEvents = buffer; evt.Visit(this); }, YieldFinalEvents)); }
public static IEnumerableAsync <MessagePrefixesPair[]> MatchPrefixes(this IEnumerableAsync <Message[]> input, IPrefixMatcher prefixMatcher) { return(input.Select( msgs => msgs.Select( m => new MessagePrefixesPair(m, prefixMatcher.Match(m.Text)) ).ToArray() )); }
public static IEnumerableAsync <MessagePrefixesPair <M>[]> MatchTextPrefixes <M>(this IEnumerableAsync <M[]> input, IPrefixMatcher prefixMatcher) where M : ITriggerText { return(input.Select( msgs => msgs.Select( m => new MessagePrefixesPair <M>(m, prefixMatcher.Match(m.Text)) ).ToArray() )); }
public IEnumerableAsync <Timeline.Event[]> GetEvents(IEnumerableAsync <Message[]> input) { return(input.Select <Message, Timeline.Event>((evt, buffer) => { lastMessage = evt; }, (buffer) => { var trigger = lastMessage != null ? triggetSelector(lastMessage) : null; if (trigger != null) { buffer.Enqueue(new EndOfTimelineEvent(trigger, null)); } })); }
public static IEnumerableAsync <Event[]> TrackTemplates(this ICodepathTracker codepathTracker, IEnumerableAsync <Event[]> events) { return(events.Select(batch => { if (codepathTracker != null) { foreach (var e in batch) { codepathTracker.RegisterUsage(e.TemplateId); } } return batch; })); }
internal static IEnumerableAsync <Adapter> CreateOrUpdateBatch(IEnumerableAsync <Adapter> keyAndConnectorKvps, Guid integrationId, string resourceType) { return(AzureStorageRepository.Connection( azureStorageRepository => { var adapters = keyAndConnectorKvps .Select(adapter => Convert(adapter)); return azureStorageRepository .CreateOrReplaceBatch(adapters, adapter => adapter.GetId(), (successAdapter) => successAdapter, (failedAdapter) => failedAdapter) .Select(adapter => Convert(adapter)); })); }
public static IEnumerableAsync <TSelect> SelectOptionalAsync <TItem, TSelect, TResult>(this IEnumerableAsync <TItem> enumerable, Func <TItem, Func <TSelect, ISelectionResult <TSelect> >, Func <ISelectionResult <TSelect> >, Task <ISelectionResult <TSelect> > > selectionAsync) { return(enumerable .Select( (item) => selectionAsync(item, (selected) => new Selection <TSelect>(selected), () => new SelectionSkipped <TSelect>())) .Await() .Where(select => select.HasValue) .Select(select => select.Value)); }
public static TResult SelectOptional <TItem, TSelect, TCarry, TResult>(this IEnumerableAsync <TItem> enumerable, TCarry carry, Func <TItem, TCarry, Func <TSelect, TCarry, ISelectionResult <TSelect> >, Func <TCarry, ISelectionResult <TSelect> >, ISelectionResult <TSelect> > selection, Func <IEnumerableAsync <TSelect>, TCarry, TResult> aggregation) { var aggregatedItems = enumerable .Select( item => selection(item, carry, (selected, carryUpdated) => { carry = carryUpdated; return(new Selection <TSelect>(selected)); }, (carryUpdated) => { carry = carryUpdated; return(new SelectionSkipped <TSelect>()); })) .Where(item => item.HasValue) .Select(item => item.Value); return(aggregation(aggregatedItems, carry)); }
public IEnumerableAsync <Event[]> GetEvents(IEnumerableAsync <Message[]> input) { return(input.Select <Message, Event>(GetEvents)); }
IEnumerableAsync <Event[]> IMediaStateInspector.GetEvents(IEnumerableAsync <MessagePrefixesPair[]> input) { return(input.Select <MessagePrefixesPair, Event>(GetEvents, GetFinalEvents, e => e.SetTags(tags))); }
IEnumerableAsync <Event[]> ICITimelineEvents.GetEvents(IEnumerableAsync <CDL.Message[]> input) { return(input.Select <CDL.Message, Event>(GetEvents, GetFinalEvents)); }
IEnumerableAsync <Event[]> IMessagingEvents.GetEvents(IEnumerableAsync <Message[]> input) { return(input.Select <Message, Event>(GetEvents)); }
public static Task <IRefs <T> > AsRefsAsync <T>(this IEnumerableAsync <IRef <T> > refs) where T : IReferenceable { return(refs.Select(r => r.id).AsRefsAsync <T>()); }
IEnumerableAsync <Event[]> ITimelineEvents.GetEvents(IEnumerableAsync <MessagePrefixesPair <Message>[]> input) { return(input.Select <MessagePrefixesPair <Message>, Event>(GetEvents, GetFinalEvents, e => e.SetTags(tags))); }
IEnumerableAsync <Event[]> ITimelineEvents.GetEvents(IEnumerableAsync <MessagePrefixesPair[]> input) { return(input.Select <MessagePrefixesPair, Event>(GetEvents, GetFinalEvents)); }
public IEnumerableAsync <Timeline.Event[]> GetEvents(IEnumerableAsync <Messaging.Event[]> input) { return(input.Select <Messaging.Event, Timeline.Event> (GetEvents)); }
public IEnumeratorAsync <KeyValuePair <TKey, TValue> > GetEnumerator() => enumerable .Select( item => this.valueSelector(item).PairWithKey(this.keySelector(item))) .GetEnumerator();
IEnumerableAsync <Event[]> IWebRtcStateInspector.GetEvents(IEnumerableAsync <MessagePrefixesPair[]> input) { return(input.Select <MessagePrefixesPair, Event>(GetEvents, GetFinalEvents)); }
IEnumerableAsync<Event[]> IWebRtcStateInspector.GetEvents(IEnumerableAsync<MessagePrefixesPair<Message>[]> input) { return input.Select<MessagePrefixesPair<Message>, Event>(GetEvents, GetFinalEvents, e => e.SetTags(tags)); }
/// <summary> /// Makes sure events have correct timestamp and go in correct order. /// Chromedriver log has a problem that timestamps at beginning of lines like [1525678451.879] /// seem to be rounded up to next 100ms boundary which results to inaccurate views. /// Most important messages like Network.requestWillBeSent have "timestamp" as a json field. /// That "timestamp" is nr os seconds from unknown origin. Luckily some messages also have /// "wallTime" in json payload that can help interpret "timestamp". /// Another problem is that "timestamp" of Network.requestWillBeSent might not match /// timing.requestTime in Network.responseReceived. The latter seems to be more accurate. /// However if a request is served from cache its timing.requestTime is totally wrong and /// should be ignored in favor of Network.requestWillBeSent's "timestamp". /// </summary> static IEnumerableAsync <Message[]> FixTimestamps(IEnumerableAsync <Message[]> messages) { DateTime?timestampBase = null; var pendingMessages = new List <MessageEntry>(); var queue = new VCSKicksCollection.PriorityQueue <MessageEntry>(new Comparer()); var queuedRequestStarts = new Dictionary <string, MessageEntry>(); double? lastDequeuedTimestamp = null; Action <Queue <Message> > dequeue = (outputQueue) => { var entry = queue.Dequeue(); if (!entry.IsInvalidated) { if (lastDequeuedTimestamp == null || entry.Timestamp != null) { lastDequeuedTimestamp = entry.Timestamp; } outputQueue.Enqueue(entry.Msg); if (entry.Type == MessageEntry.EntryType.StartRequest) { queuedRequestStarts.Remove(entry.RequestId); } } }; Action <MessageEntry> enqueue = null; enqueue = (r) => { var rebased = r.Rebase(timestampBase.Value); queue.Enqueue(rebased); if (r.Type == MessageEntry.EntryType.StartRequest) { queuedRequestStarts[r.RequestId] = rebased; } else if (r.Type == MessageEntry.EntryType.ResponseWithTiming) { MessageEntry queuedRequest; if (queuedRequestStarts.TryGetValue(r.RequestId, out queuedRequest) && !queuedRequest.IsInvalidated && !queuedRequest.IsServedFromCache) { if (lastDequeuedTimestamp == null || r.ResponseTiming_RequestTime > lastDequeuedTimestamp.Value) { enqueue(queuedRequest.InvalidateAndMakeFixedStartRequest(r.ResponseTiming_RequestTime)); } } } else if (r.Type == MessageEntry.EntryType.ServedFromCache) { MessageEntry queuedRequest; if (queuedRequestStarts.TryGetValue(r.RequestId, out queuedRequest)) { queuedRequest.IsServedFromCache = true; } } }; Action flushPendingMessages = () => { foreach (var pendingMessage in pendingMessages) { enqueue(pendingMessage); } pendingMessages.Clear(); }; int queueSize = 4096; return(messages.Select <Message, Message>((m, outputQueue) => { var newEntry = new MessageEntry(m); if (timestampBase == null && newEntry.Timestamp != null && newEntry.WallTime != null) { timestampBase = TimeUtils.UnixTimestampMillisToDateTime( newEntry.WallTime.Value * 1000d).ToUnspecifiedTime().AddSeconds( -newEntry.Timestamp.Value); flushPendingMessages(); } if (timestampBase == null) { pendingMessages.Add(newEntry); } else { enqueue(newEntry); } if (queue.Count >= queueSize * 2) { while (queue.Count > queueSize) { dequeue(outputQueue); } } }, (outputQueue) => { while (queue.Count > 0) { dequeue(outputQueue); } })); }
public static IEnumerableAsync <TValue> SelectValues <TKey, TValue>(this IEnumerableAsync <KeyValuePair <TKey, TValue> > enumerable) { return(enumerable.Select(kvp => kvp.Value)); }