EventStatisticsCommand.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Markdown;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Service.IoTBroker.Sources.Reports.Events.Commands
{
    public class EventStatisticsCommand : ExecuteServerAdminReport
    {
        public EventStatisticsCommand(EventStatisticsNode ReportNode)
            : base(ReportNode)
        {
        }
 
        [Page(7, "Time", 150)]
        [Header(8, "From:")]
        [ToolTip(9, "Search for events from this point in time.")]
        public DateTime From = DateTime.Today.AddDays(-1);
 
        [Page(7, "Time", 150)]
        [Header(10, "To:")]
        [ToolTip(11, "Search for events to this point in time.")]
        public DateTime To = DateTime.Today.AddDays(1);
 
        public override Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(SearchEventsCommand), 59, "Statistics...");
        }
 
        public override ICommand Copy()
        {
            return new EventStatisticsCommand((EventStatisticsNode)this.Report)
            {
                From = this.From,
                To = this.To
            };
        }
 
        public override Task StartQueryExecutionAsync(Query Query, Language Language)
        {
            this.Execute(Query, Language);
            return Task.CompletedTask;
        }
 
        private async void Execute(Query Query, Language Language)
        {
            try
            {
                await Query.Start();
                await Query.SetTitle(await Language.GetStringAsync(typeof(SearchEventsCommand), 47, "Events"));
 
                if (this.To < this.From)
                {
                    DateTime Temp = this.To;
                    this.To = this.From;
                    this.From = Temp;
                }
 
                List<Filter> Filters = new List<Filter>();
                if (this.From > DateTime.MinValue)
                    Filters.Add(new FilterFieldGreaterOrEqualTo("Timestamp", this.From));
 
                if (this.To < DateTime.MaxValue)
                    Filters.Add(new FilterFieldLesserOrEqualTo("Timestamp", this.To));
 
                await Query.SetStatus(await Language.GetStringAsync(typeof(SearchEventsCommand), 48, "Searching database..."));
 
                IEnumerable<EventStatistic> Records = Filters.Count switch
                {
                    0 => await Database.Find<EventStatistic>("Timestamp"),
                    1 => await Database.Find<EventStatistic>(Filters[0], "Timestamp"),
                    _ => await Database.Find<EventStatistic>(new FilterAnd(Filters.ToArray()), "Timestamp"),
                };
 
                await this.ReportRecords(Records, Query, Language, "PerType",
                    await Language.GetStringAsync(typeof(SearchEventsCommand), 61, "Events per Type"));
 
                await this.ReportRecords(Records, Query, Language, "PerLevel",
                    await Language.GetStringAsync(typeof(SearchEventsCommand), 62, "Events per Level"));
 
                await this.ReportRecords(Records, Query, Language, "PerEventId",
                    await Language.GetStringAsync(typeof(SearchEventsCommand), 63, "Events per Event ID"));
 
                await this.ReportRecords(Records, Query, Language, "PerActor",
                    await Language.GetStringAsync(typeof(SearchEventsCommand), 64, "Events per Actor"));
 
                await this.ReportRecords(Records, Query, Language, "PerModule",
                    await Language.GetStringAsync(typeof(SearchEventsCommand), 65, "Events per Module"));
 
                await this.ReportRecords(Records, Query, Language, "PerFacility",
                    await Language.GetStringAsync(typeof(SearchEventsCommand), 66, "Events per Facility"));
 
                await this.ReportStackTraces(Records, Query, Language);
            }
            catch (Exception ex)
            {
                await Query.LogMessage(ex);
            }
            finally
            {
                await Query.Done();
            }
        }
 
        private async Task ReportRecords(IEnumerable<EventStatistic> Records, Query Query, Language Language,
            string Property, string SectionName)
        {
            SortedDictionary<string, int> Labels = new SortedDictionary<string, int>();
            PropertyInfo PI = typeof(EventStatistic).GetProperty(Property);
            int i = 0;
 
            foreach (EventStatistic Rec in Records)
            {
                foreach (Statistic Stat in (Statistic[])PI.GetValue(Rec))
                {
                    if (!Labels.ContainsKey(Stat.Name))
                        Labels[Stat.Name] = i++;
                }
            }
 
            List<Column> Columns = new List<Column>()
            {
                new Column("Start", await Language.GetStringAsync(typeof(SearchEventsCommand), 60, "Start"),
                    null, null, null, null, ColumnAlignment.Left, null),
                new Column("Timestamp", await Language.GetStringAsync(typeof(SearchEventsCommand), 50, "Timestamp"),
                    null, null, null, null, ColumnAlignment.Left, null)
            };
 
            SortedDictionary<string, int> IndexByName = new SortedDictionary<string, int>();
            i = 2;
 
            foreach (KeyValuePair<string, int> Header in Labels)
            {
                Columns.Add(new Column("C" + Header.Value.ToString(), Header.Key, null, null, null, null, ColumnAlignment.Right, null));
                IndexByName[Header.Key] = i++;
            }
 
            int c = Columns.Count;
 
            await Query.BeginSection(SectionName);
            await Query.NewTable(Property, SectionName, Columns.ToArray());
 
            foreach (EventStatistic Rec in Records)
            {
                object[] Record = new object[c];
                Record[0] = Rec.Start;
                Record[1] = Rec.Timestamp;
 
                foreach (Statistic Stat in (Statistic[])PI.GetValue(Rec))
                {
                    if (IndexByName.TryGetValue(Stat.Name, out i))
                        Record[i] = Stat.Count;
                }
 
                await Query.NewRecords(Property, new Record(Record));
            }
 
            await Query.TableDone(Property);
            await Query.EndSection();
        }
 
        private async Task ReportStackTraces(IEnumerable<EventStatistic> Records, Query Query, Language Language)
        {
            SortedDictionary<string, int> Labels = new SortedDictionary<string, int>();
            int i = 0;
 
            foreach (EventStatistic Rec in Records)
            {
                foreach (Statistic Stat in Rec.PerStackTrace)
                {
                    if (!Labels.ContainsKey(Stat.Name))
                        Labels[Stat.Name] = i++;
                }
            }
 
            List<Column> Columns = new List<Column>()
            {
                new Column("Start", await Language.GetStringAsync(typeof(SearchEventsCommand), 60, "Start"),
                    null, null, null, null, ColumnAlignment.Left, null),
                new Column("Timestamp", await Language.GetStringAsync(typeof(SearchEventsCommand), 50, "Timestamp"),
                    null, null, null, null, ColumnAlignment.Left, null),
                new Column("Count", await Language.GetStringAsync(typeof(SearchEventsCommand), 68, "Count"),
                    null, null, null, null, ColumnAlignment.Right, null)
            };
 
            await Query.BeginSection(await Language.GetStringAsync(typeof(SearchEventsCommand), 67, "Events per Stack Trace"));
 
            string StackTraceLabel = await Language.GetStringAsync(typeof(SearchEventsCommand), 69, "Stack Trace");
 
            i = 0;
 
            foreach (string StackTrace in Labels.Keys)
            {
                StringBuilder Markdown = new StringBuilder();
 
                Markdown.AppendLine("```");
                Markdown.AppendLine(StackTrace);
                Markdown.AppendLine("```");
 
                await Query.NewObject(new MarkdownContent(Markdown.ToString()));
 
                string TableId = "T" + i++.ToString();
 
                await Query.NewTable(TableId, StackTraceLabel + " " + i.ToString(), Columns.ToArray());
 
                foreach (EventStatistic Rec in Records)
                {
                    object[] Record = new object[]
                    {
                        Rec.Start,
                        Rec.Timestamp,
                        0
                    };
 
                    foreach (Statistic Stat in Rec.PerStackTrace)
                    {
                        if (Stat.Name == StackTrace)
                        {
                            Record[2] = Stat.Count;
                            break;
                        }
                    }
 
                    await Query.NewRecords(TableId, new Record(Record));
                }
 
                await Query.TableDone(TableId);
            }
 
            await Query.EndSection();
        }
 
    }
}