LockedObjectsCommand.cs

using System;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Runtime.Language;
using Waher.Runtime.Threading;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Service.IoTBroker.Sources.Reports.Performance.Commands
{
    public class LockedObjectsCommand : ExecuteServerAdminReport
    {
        public LockedObjectsCommand(ServerAdminReportNode Report)
            : base(Report)
        {
        }
 
        [Page(1, "Time", 150)]
        [Header(24, "Threshold (ms):")]
        [ToolTip(25, "Search for objects that have been locked for more time than this number of milliseconds.")]
        public int Milliseconds = 10000;
 
        [Page(1, "Time", 150)]
        [Header(37, "Remove System References.")]
        [ToolTip(38, "Remove System Refernces from stack traces in report.")]
        public bool RemoveSystemReferences = true;
 
        [Page(1, "Time", 150)]
        [Header(41, "Only objects with waiting tasks.")]
        [ToolTip(42, "Only include objects with tasks actively waiting for object to be released.")]
        public bool OnlyIfWaitingTasks = true;
 
        public override Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(SampleStatisticsCommand), 26, "Locked Objects...");
        }
 
        public override ICommand Copy()
        {
            return new LockedObjectsCommand((ServerAdminReportNode)this.Report)
            {
                Milliseconds = this.Milliseconds,
                RemoveSystemReferences = this.RemoveSystemReferences
            };
        }
 
        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();
 
                string Title = await Language.GetStringAsync(typeof(LockedObjectsCommand), 27, "Locked Objects");
                await Query.SetTitle(Title);
                await Query.BeginSection(Title);
 
                MultiReadSingleWriteObject[] Objects = Semaphores.FindLockedObjects(this.Milliseconds, this.OnlyIfWaitingTasks);
                int i, c = Objects.Length;
 
                if (c == 0)
                    await Query.NewObject(await Language.GetStringAsync(typeof(LockedObjectsCommand), 28, "No locked objects found past the threshold."));
                else
                {
                    await Query.NewTable("Objects",
                        await Language.GetStringAsync(typeof(LockedObjectsCommand), 29, "Objects"),
                        new Column("Index",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 31, "Nr"),
                            null, null, null, null, ColumnAlignment.Right, null),
                        new Column("Owner",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 30, "Owner"),
                            null, null, null, null, ColumnAlignment.Left, null),
                        new Column("QueueSize",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 40, "Queued"),
                            null, null, null, null, ColumnAlignment.Right, null),
                        new Column("Token",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 39, "Token"),
                            null, null, null, null, ColumnAlignment.Right, null),
                        new Column("NrReaders",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 32, "#Readers"),
                            null, null, null, null, ColumnAlignment.Right, null),
                        new Column("IsWriting",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 33, "Writing"),
                            null, null, null, null, ColumnAlignment.Center, null),
                        new Column("Time",
                            await Language.GetStringAsync(typeof(LockedObjectsCommand), 1, "Time"),
                            null, null, null, null, ColumnAlignment.Right, null));
 
                    Record[] Records = new Record[c];
                    MultiReadSingleWriteObject Obj;
 
                    for (i = 0; i < c; i++)
                    {
                        Obj = Objects[i];
 
                        string Unit = "ms";
                        double d = Obj.MillisecondsLocked;
                        byte NrDec = 0;
 
                        if (d >= 1000)
                        {
                            d /= 1000;
                            Unit = "s";
                            NrDec = 2;
 
                            if (d >= 60)
                            {
                                d /= 60;
                                Unit = "min";
 
                                if (d >= 60)
                                {
                                    d /= 60;
                                    Unit = "h";
 
                                    if (d >= 24)
                                    {
                                        d /= 24;
                                        Unit = "d";
 
                                        if (d >= 7)
                                        {
                                            d /= 7;
                                            Unit = "w";
                                        }
                                    }
                                }
                            }
                        }
 
                        Records[i] = new Record(
                            i + 1,
                            Obj.Owner?.ToString() ?? "NULL",
                            Obj.QueueSize,
                            Obj.Token,
                            Obj.NrReaders,
                            Obj.IsWriting,
                            CommonTypes.Encode(d, NrDec) + " " + Unit);
 
                        if (Obj.RecordStackTraces)
                        {
                            Title = (await Language.GetStringAsync(typeof(LockedObjectsCommand), 34, "Object %0%")).Replace("%0%", (i + 1).ToString());
 
                            if (!(Obj.Owner is null))
                                Title += ": " + Obj.Owner.ToString();
 
                            await Query.BeginSection(Title);
 
                            if (!string.IsNullOrEmpty(Obj.CreatorStackTrace))
                            {
                                await Query.BeginSection(await Language.GetStringAsync(typeof(LockedObjectsCommand), 35, "Creator"));
                                await Query.NewObject(this.ReportStackTrace(Obj.CreatorStackTrace));
                                await Query.EndSection();
                            }
 
                            if (!string.IsNullOrEmpty(Obj.LockStackTrace))
                            {
                                await Query.BeginSection(await Language.GetStringAsync(typeof(LockedObjectsCommand), 36, "Lock"));
                                await Query.NewObject(this.ReportStackTrace(Obj.LockStackTrace));
                                await Query.EndSection();
                            }
 
                            int j = 0;
 
                            foreach (string PendingStackTrace in Obj.QueuedStackTraces)
                            {
                                await Query.BeginSection((await Language.GetStringAsync(typeof(LockedObjectsCommand), 43, "Queued Stack Trace %0%")).Replace("%0%", (++j).ToString()));
                                await Query.NewObject(this.ReportStackTrace(PendingStackTrace));
                                await Query.EndSection();
                            }
 
                            await Query.EndSection();
                        }
                    }
 
                    await Query.NewRecords("Objects", Records);
                    await Query.TableDone("Objects");
                }
            
                await Query.EndSection();
            }
            catch (Exception ex)
            {
                await Query.LogMessage(ex);
            }
            finally
            {
                await Query.Done();
            }
        }
 
        private MarkdownContent ReportStackTrace(string StackTrace)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.AppendLine("```");
 
            if (this.RemoveSystemReferences)
            {
                string[] Rows = StackTrace.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
 
                foreach (string Row in Rows)
                {
                    if (Row.TrimStart().StartsWith("at System."))
                        continue;
 
                    sb.AppendLine(Row);
                }
            }
            else
                sb.AppendLine(StackTrace.TrimEnd());
 
            sb.AppendLine("```");
 
            return new MarkdownContent(sb.ToString());
        }
    }
}