internal static Task<TxReader> GetReader(IEnumerable<string> etlFileName, bool isRealtime = false)
{
TaskCompletionSource<TxReader> tsc = new TaskCompletionSource<TxReader>();
TxReader reader = new TxReader(etlFileName, isRealtime);
tsc.SetResult(reader);
return tsc.Task;
}
string GetFilterString(TxReader reader)
{
StringBuilder sb = new StringBuilder();
if (reader.ShouldFilterByWhere)
{
sb.Append(reader.WhereFilter);
}
if (reader.ShouldFilterTimeWindow)
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append("From:" + new DateTime(reader.StartTime))
.Append(" To:" + new DateTime(reader.EndTime));
}
if (reader.ShouldFilterProviders)
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append("Providers:")
.AppendLine(reader.EnabledProviders.Select((e) => e.ToString()).Aggregate((curr, next) => curr + "," + next));
}
//TODO: Add other filters.
return(sb.ToString());
}
internal void Filter(TxReader reader)
{
var func = this.GetViewFilter(reader);
int count = 0;
if (func == null)
{
this.CurrenView.Filter = TrueFilter;
}
else
{
EventRecordProxy previous = null;
this.CurrenView.Filter = (e) =>
{
EventRecordProxy curr = (EventRecordProxy)e;
if (func(curr))
{
curr.Previous = previous;
previous = curr;
count++;
return(true);
}
return(false);
};
}
this.FilteredRowCount = count;
}
internal string UpdateReaderFilters(TxReader reader)
{
string filter = this.FilterText.Trim();
Contract.Assert(reader != null);
reader.SetEnabledProviders(this.SeletectedProviders);
reader.SetKeywordFilter(this.SelectedKeywords);
reader.SetWhereFilter(filter);
return(this.GetFilterString(reader));
}
public Task InitializeSession(string[] sessions)
{
TaskScheduler context = TaskScheduler.FromCurrentSynchronizationContext();
var readerTask = TxHelper.GetReader(sessions, true);
return(readerTask.ContinueWith((t) =>
{
this.reader = t.Result;
this.IsRealTime = true;
this.Session = sessions.Aggregate((p, c) => p + "," + c);
}, context));
}
Func <EventRecordProxy, bool> GetViewFilter(TxReader reader)
{
Func <EventRecordProxy, bool> where = null;
if (reader.ShouldFilterByWhere)
{
where = FilterParser.ParseWhere <EventRecordProxy>(reader.WhereFilter);
}
Func <EventRecordProxy, bool> func = (e) =>
{
if (reader.ShouldFilterTimeWindow && !reader.TimeFilter(e.TimeStamp.Ticks))
{
return(false);
}
if (reader.ShouldFilterKeywords && !reader.KeywordFilter(e.Keywords))
{
return(false);
}
if (reader.ShouldFilterProviders && !reader.ProviderFilter(e.ProviderId))
{
return(false);
}
if (reader.ShouldFilterByWhere && !where (e))
{
return(false);
}
return(true);
};
return(func);
}
void LoadTimeLineAsync()
{
this.Model.StartActivity("Loading timeline....");
TaskScheduler scheduler = TaskScheduler.FromCurrentSynchronizationContext();
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
this.timelineLoadingTask = tcs.Task;
TxReader reader = this.Model.Reader;
Contract.Assert(reader != null);
int bufferSize = 5000;
int count = 0;
this.EventTimeline.StartLoad();
this.TimelinePanel.Visibility = System.Windows.Visibility.Visible;
Task timelineTask = new Task(() =>
{
var timeline = reader.GetRawEventsForTimeWindow();
var q = from e in timeline
select new TimelineEvent
{
Level = (byte)(e.Level % 6),
Ticks = e.TimeStamp.Ticks
};
q.Buffer(bufferSize)
.Finally(() => tcs.SetResult(null))
.Subscribe((data) =>
{
count += data.Count;
this.Dispatcher.BeginInvoke(((Action)(() =>
{
this.TimelineModel.Populate(data);
this.Model.LogActivity(String.Format("Timeline Loaded {0} Events", count));
})));
});
});
timelineTask.Start();
timelineTask.ContinueWith((t) =>
{
if (t.IsFaulted)
{
tcs.SetException(t.Exception);
}
});
tcs.Task.ContinueWith((loadingTask) =>
{
if (loadingTask.IsFaulted)
{
ExceptionHelper.ShowException(loadingTask.Exception);
return;
}
this.EventTimeline.LoadComplete();
this.Model.StartTime = this.TimelineModel.StartTime;
this.Model.StopTime = this.TimelineModel.StopTime;
this.Model.StopActivity(String.Format("Loaded with {0} events in {1}", count, this.Model.ActivityDuration.TotalSeconds));
if (!reader.SessionWindowInitialized)
{
reader.SessionWindowInitialized = true;
reader.SessionStartTime = this.Model.StartTime;
reader.SessionStopTime = this.Model.StopTime;
}
}, scheduler);
}
void RefreshGrid()
{
Logger.Log("Refreshing grid.");
TxReader reader = this.Model.Reader;
IList <EventRecordProxy> events = null;
int bufferCount = reader.IsRealtime ? 1 : 1000;
IObservable <EventRecordProxy> observable = null;
IDisposable subscriber = null;
TaskCompletionSource <object> eventLoading = new TaskCompletionSource <object>();
TaskScheduler scheduler = TaskScheduler.FromCurrentSynchronizationContext();
Action <IList <EventRecordProxy>, IList <EventRecordProxy> > AddRange = (list, data) =>
{
lock (list)
{
EventRecordProxy prev = list.Count > 0 ? list[list.Count - 1] : null;
foreach (var item in data)
{
item.Previous = prev;
list.Add(item);
prev = item;
}
}
};
Action onComplete = () =>
{
if (!eventLoading.Task.IsCompleted &&
!eventLoading.Task.IsFaulted)
{
eventLoading.SetResult(null);
}
};
try
{
observable = this.Model.GetObservable();
// Starting grid loading
this.Model.StartActivity("Loading events ....");
if (reader.IsRealtime)
{
events = new ObservableCollection <EventRecordProxy>();
this.EventsModel.Items = events;
this.loadingAdorner.Visibility = System.Windows.Visibility.Hidden;
}
else
{
events = new List <EventRecordProxy>();
this.loadingAdorner.Message = "Event loading in progress.";
this.loadingAdorner.Visibility = System.Windows.Visibility.Visible;
}
subscriber = observable
.Buffer(bufferCount)
// TODO why posting on the UI thread doesn't work
// .SubscribeOn(SynchronizationContext.Current)
.Finally(onComplete)
.Subscribe(loadedData =>
{
try
{
if (reader.IsRealtime)
{
this.Post(() => AddRange(events, loadedData));
}
else
{
AddRange(events, loadedData);
}
this.Post(() =>
{
this.Model.LogActivity(string.Format("Loaded {0} events ", events.Count));
});
}
catch (Exception ex)
{
eventLoading.SetException(ex);
}
},
(exception) =>
{
eventLoading.SetException(exception);
Logger.Log(exception);
this.Post(() =>
{
this.Model.StopActivity(exception.Message);
});
});
reader.StartPublish(observable);
}
catch (Exception ex)
{
eventLoading.SetException(ex);
}
eventLoading.Task.ContinueWith((t) =>
{
if (t.IsFaulted)
{
Logger.Log(t.Exception);
this.Model.StopReaderCommand.Execute(null);
this.Model.StopActivity("Could not load events");
this.FilterModel.FilterException = t.Exception;
this.loadingAdorner.Visibility = System.Windows.Visibility.Hidden;
return;
}
if (reader.IsRealtime)
{
return;
}
else
{
//Finally set the item source to avoid adding on bound item collection.
this.EventsModel.Items = events;
this.loadingAdorner.Visibility = System.Windows.Visibility.Hidden;
this.Model.StopActivity(string.Format(
"Loaded {0} in {1} seconds",
events.Count,
this.Model.ActivityDuration.TotalSeconds));
// Switch to View mode after filtering source automatically.
this.FilterModel.Mode = FilterMode.View;
}
}, scheduler);
}
string GetFilterString(TxReader reader)
{
StringBuilder sb = new StringBuilder();
if (reader.ShouldFilterByWhere)
{
sb.Append(reader.WhereFilter);
}
if (reader.ShouldFilterTimeWindow)
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append("From:" + new DateTime(reader.StartTime))
.Append(" To:" + new DateTime(reader.EndTime));
}
if (reader.ShouldFilterProviders)
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append("Providers:")
.AppendLine(reader.EnabledProviders.Select((e) => e.ToString()).Aggregate((curr, next) => curr + "," + next));
}
//TODO: Add other filters.
return sb.ToString();
}
internal string UpdateReaderFilters(TxReader reader)
{
string filter = this.FilterText.Trim();
Contract.Assert(reader != null);
reader.SetEnabledProviders(this.SeletectedProviders);
reader.SetKeywordFilter(this.SelectedKeywords);
reader.SetWhereFilter(filter);
return this.GetFilterString(reader);
}
Func<EventRecordProxy, bool> GetViewFilter(TxReader reader)
{
Func<EventRecordProxy, bool> where = null;
if (reader.ShouldFilterByWhere)
{
where = FilterParser.ParseWhere<EventRecordProxy>(reader.WhereFilter);
}
Func<EventRecordProxy, bool> func = (e) =>
{
if (reader.ShouldFilterTimeWindow && !reader.TimeFilter(e.TimeStamp.Ticks))
{
return false;
}
if (reader.ShouldFilterKeywords && !reader.KeywordFilter(e.Keywords))
{
return false;
}
if (reader.ShouldFilterProviders && !reader.ProviderFilter(e.ProviderId))
{
return false;
}
if (reader.ShouldFilterByWhere && !where(e))
{
return false;
}
return true;
};
return func;
}
internal void Filter(TxReader reader)
{
var func = this.GetViewFilter(reader);
int count = 0;
if (func == null)
{
this.CurrenView.Filter = TrueFilter;
}
else
{
EventRecordProxy previous = null;
this.CurrenView.Filter = (e) =>
{
EventRecordProxy curr = (EventRecordProxy)e;
if (func(curr))
{
curr.Previous = previous;
previous = curr;
count++;
return true;
}
return false;
};
}
this.FilteredRowCount = count;
}
