EventLogComponent.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Events.Persistence;
using Waher.Events.XMPP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Service.IoTBroker.Provisioning.Registry;
 
namespace Waher.Service.IoTBroker.Events
{
    public class EventLogComponent : Component
    {
        public const string NamespaceEventLog = "urn:xmpp:eventlog";
 
        public const string NamespaceSearch = "jabber:iq:search";
 
        public const string NamespaceDataForm = "jabber:x:data";
 
        public EventLogComponent(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
            : base(Server, Subdomain, Name)
        {
            this.RegisterMessageHandler("log", NamespaceEventLog, this.LogHandler, true);
 
            this.RegisterIqGetHandler("query", NamespaceSearch, this.SearchQueryHandler, true);
            this.RegisterIqSetHandler("query", NamespaceSearch, this.SearchHandler, false);
        }
 
        public override void Dispose()
        {
            this.UnregisterMessageHandler("log", NamespaceEventLog, this.LogHandler, true);
 
            this.UnregisterIqGetHandler("query", NamespaceSearch, this.SearchQueryHandler, true);
            this.UnregisterIqSetHandler("query", NamespaceSearch, this.SearchHandler, false);
        }
 
        public override bool SupportsAccounts => false;
 
        private async Task LogHandler(object Sender, MessageEventArgs e)
        {
            CaseInsensitiveString FromBareJid = e.From.BareJid;
            int i = FromBareJid.IndexOf('@');
            if (i < 0)
                return; // Ignore log events from non-client senders.
 
            CaseInsensitiveString FromDomain = FromBareJid.Substring(i + 1);
            if (!this.Server.IsServerDomain(FromDomain, true))
                return; // Ignore log events from clients not connected to the current server.
 
            CaseInsensitiveString FromUserName = FromBareJid.Substring(0, i);
 
            IAccount Account = await XmppServerModule.GetAccountAsync(FromUserName);
            if (Account is null)
                return; // Ignore from senders that are not accounts.
 
            XmlElement E = e.Content;
            XmlElement E2;
            List<KeyValuePair<string, object>> Tags = new List<KeyValuePair<string, object>>();
            DateTime Timestamp = XML.Attribute(E, "timestamp", DateTime.MinValue);
            string EventId = XML.Attribute(E, "id");
            EventType Type = XML.Attribute(E, "type", EventType.Informational);
            EventLevel Level = XML.Attribute(E, "level", EventLevel.Minor);
            string Object = XML.Attribute(E, "object");
            string Actor = XML.Attribute(E, "subject");
            string Facility = XML.Attribute(E, "facility");
            string Module = XML.Attribute(E, "module");
            string Message = string.Empty;
            string StackTrace = string.Empty;
 
            foreach (XmlNode N in E.ChildNodes)
            {
                switch (N.LocalName)
                {
                    case "message":
                        Message = N.InnerText;
                        break;
 
                    case "tag":
                        E2 = (XmlElement)N;
                        string TagName = XML.Attribute(E2, "name");
                        string TagValue = XML.Attribute(E2, "value");
                        string TagType = XML.Attribute(E2, "type");
 
                        if (!XmppEventReceptor.TryParse(TagValue, TagType, out object TagValueParsed))
                            TagValueParsed = TagValue;
 
                        Tags.Add(new KeyValuePair<string, object>(TagName, TagValueParsed));
                        break;
 
                    case "stackTrace":
                        StackTrace = N.InnerText;
                        break;
                }
            }
 
            if (string.IsNullOrEmpty(Facility))
                Facility = FromBareJid;
 
            Event Event = new Event(Timestamp, Type, Message, Object, Actor, EventId, Level, Facility, Module, StackTrace, Tags.ToArray());
 
            Log.Event(Event);
 
            RegistryAccount RegistryAccount = await Provisioning.ProvisioningComponent.GetAccount(FromBareJid);
            RegistryAccount.NrLogMessages++;
        }
 
        private async Task SearchQueryHandler(object Sender, IqEventArgs e)
        {
            if (!await XmppServerModule.IsAdmin(e.From.Address))
            {
                await e.IqErrorForbidden(e.To, "Access denied. Not sufficient privileges to perform search.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
            string Instructions = "Limit the search on events by entering values in one or more fields below. Use asterisks (*) for wildcard searches.";
 
            Xml.Append("<query xmlns='");
            Xml.Append(NamespaceSearch);
            Xml.Append("'><instructions>");
            Xml.Append(Instructions);
            Xml.Append("</instructions>");
            Xml.Append("<x xmlns='");
            Xml.Append(NamespaceDataForm);
            Xml.Append("' xmlns:xdv='http://jabber.org/protocol/xdata-validate' type='form'><title>Event Log Search</title><instructions>");
            Xml.Append(Instructions);
            Xml.Append("</instructions><field type='hidden' var='FORM_TYPE'><value>");
            Xml.Append(NamespaceSearch);
            Xml.Append("</value></field>");
 
            Xml.Append("<field type='text-single' label ='From:' var='From'>");
            Xml.Append("<desc>Search for events newer than this.</desc>");
            Xml.Append("<required/>");
            Xml.Append("<xdv:validate datatype='xs:dateTime'/>");
            Xml.Append("<value>");
            Xml.Append(XML.Encode(DateTime.Now.AddHours(-1)));
            Xml.Append("</value>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='To:' var='To'>");
            Xml.Append("<desc>Search for events older than this.</desc>");
            Xml.Append("<required/>");
            Xml.Append("<xdv:validate datatype='xs:dateTime'/>");
            Xml.Append("<value>");
            Xml.Append(XML.Encode(DateTime.Now));
            Xml.Append("</value>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='list-single' label ='Type:' var='Type'>");
            Xml.Append("<desc>Choose event types.</desc>");
            Xml.Append("<value>All</value>");
            Xml.Append("<option label='All'><value>All</value></option>");
 
            foreach (string Name in Enum.GetNames(typeof(EventType)))
            {
                Xml.Append("<option label='");
                Xml.Append(XML.Encode(Name));
                Xml.Append("'><value>");
                Xml.Append(XML.Encode(Name));
                Xml.Append("</value></option>");
            }
 
            Xml.Append("</field>");
 
            Xml.Append("<field type='list-single' label ='Level:' var='Level'>");
            Xml.Append("<desc>Choose event levels.</desc>");
            Xml.Append("<value>All</value>");
            Xml.Append("<option label='All'><value>All</value></option>");
 
            foreach (string Name in Enum.GetNames(typeof(EventLevel)))
            {
                Xml.Append("<option label='");
                Xml.Append(XML.Encode(Name));
                Xml.Append("'><value>");
                Xml.Append(XML.Encode(Name));
                Xml.Append("</value></option>");
            }
 
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Message:' var='Message'>");
            Xml.Append("<desc>Search for events containing a specific message text.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Object:' var='Object'>");
            Xml.Append("<desc>Search for events relating to a specific object.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Actor:' var='Actor'>");
            Xml.Append("<desc>Search for events relating to a specific actor.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Event ID:' var='EventId'>");
            Xml.Append("<desc>Search for events having a specific event identity.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Facility:' var='Facility'>");
            Xml.Append("<desc>Search for events coming from a specific facility.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Module:' var='Module'>");
            Xml.Append("<desc>Search for events originating in a specific module.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("<field type='text-single' label ='Stack Trace:' var='StackTrace'>");
            Xml.Append("<desc>Search for events containing a specific stack trace.</desc>");
            Xml.Append("<xdv:validate datatype='xs:string'/>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
 
            Xml.Append("</x></query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task SearchHandler(object Sender, IqEventArgs e)
        {
            if (!await XmppServerModule.IsAdmin(e.From.Address))
            {
                await e.IqErrorForbidden(e.To, "Access denied. Not sufficient privileges to perform search.", "en");
                return;
            }
 
            List<Filter> Filters = new List<Filter>();
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "x" && E.NamespaceURI == NamespaceDataForm)
                {
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (N2 is XmlElement E2 && E2.LocalName == "field")
                        {
                            XmlElement Value = E2["value"];
                            if (Value is null)
                                continue;
 
                            string Var = XML.Attribute(E2, "var");
 
                            switch (Var)
                            {
                                case "From":
                                    if (!XML.TryParse(Value.InnerText, out DateTime From))
                                    {
                                        await e.IqErrorBadRequest(e.To, "Invalid From value.", "en");
                                        return;
                                    }
 
                                    Filters.Add(new FilterFieldGreaterOrEqualTo("Timestamp", From));
                                    break;
 
                                case "To":
                                    if (!XML.TryParse(Value.InnerText, out DateTime To))
                                    {
                                        await e.IqErrorBadRequest(e.To, "Invalid To value.", "en");
                                        return;
                                    }
 
                                    Filters.Add(new FilterFieldLesserOrEqualTo("Timestamp", To));
                                    break;
 
                                case "Type":
                                    string s = E2.InnerText;
                                    if (s != "All")
                                    {
                                        if (!Enum.TryParse<EventType>(s, out EventType Type))
                                        {
                                            await e.IqErrorBadRequest(e.To, "Invalid Type value.", "en");
                                            return;
                                        }
 
                                        Filters.Add(new FilterFieldEqualTo("Type", Type));
                                    }
                                    break;
 
                                case "Level":
                                    s = E2.InnerText;
                                    if (s != "All")
                                    {
                                        if (!Enum.TryParse<EventLevel>(s, out EventLevel Level))
                                        {
                                            await e.IqErrorBadRequest(e.To, "Invalid Level value.", "en");
                                            return;
                                        }
 
                                        Filters.Add(new FilterFieldEqualTo("Level", Level));
                                    }
                                    break;
 
                                case "Message":
                                case "Object":
                                case "Actor":
                                case "EventId":
                                case "Facility":
                                case "Module":
                                case "StackTrace":
                                    s = E2.InnerText;
                                    if (!string.IsNullOrEmpty(s))
                                    {
                                        if (s.IndexOf('*') >= 0)
                                            Filters.Add(new FilterFieldLikeRegEx(Var, Database.WildcardToRegex(s, "*")));
                                        else
                                            Filters.Add(new FilterFieldEqualTo(Var, s));
                                    }
                                    break;
                            }
                        }
                    }
                }
            }
 
            Filter Filter;
 
            switch (Filters.Count)
            {
                case 0:
                    await e.IqErrorBadRequest(e.To, "Invalid search request.", "en");
                    return;
 
                case 1:
                    Filter = Filters[0];
                    break;
 
                default:
                    Filter = new FilterAnd(Filters.ToArray());
                    break;
            }
 
            StringBuilder Xml = new StringBuilder();
            Dictionary<string, string> Headers = new Dictionary<string, string>();
            List<KeyValuePair<string, string>> HeadersOrdered = new List<KeyValuePair<string, string>>()
            {
                new KeyValuePair<string, string>("Timestamp", "Timestamp"),
                new KeyValuePair<string, string>("Type", "Type"),
                new KeyValuePair<string, string>("Level", "Level"),
                new KeyValuePair<string, string>("Message", "Message"),
                new KeyValuePair<string, string>("Object", "Object"),
                new KeyValuePair<string, string>("Actor", "Actor"),
                new KeyValuePair<string, string>("EventId", "Event ID"),
                new KeyValuePair<string, string>("Facility", "Facility"),
                new KeyValuePair<string, string>("Module", "Module"),
                new KeyValuePair<string, string>("StackTrace", "Stack Trace")
            };
 
            foreach (KeyValuePair<string, string> P in HeadersOrdered)
                Headers[P.Key] = P.Value;
 
            foreach (PersistedEvent Event in await Database.Find<PersistedEvent>(Filter, "Timestamp"))
            {
                Xml.Append("<item>");
 
                Xml.Append("<field var='Timestamp'><value>");
                Xml.Append(XML.Encode(Event.Timestamp));
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Type'><value>");
                Xml.Append(Event.Type.ToString());
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Level'><value>");
                Xml.Append(Event.Level.ToString());
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Message'><value>");
                
                if (!(Event.Message is null))
                    Xml.Append(XML.Encode(Event.Message));
 
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Object'><value>");
                
                if (!(Event.Object is null))
                    Xml.Append(XML.Encode(Event.Object));
 
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Actor'><value>");
                
                if (!(Event.Actor is null))
                    Xml.Append(XML.Encode(Event.Actor));
 
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='EventId'><value>");
                
                if (!(Event.EventId is null))
                    Xml.Append(XML.Encode(Event.EventId));
 
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Facility'><value>");
                
                if (!(Event.Facility is null))
                    Xml.Append(XML.Encode(Event.Facility));
 
                Xml.Append("</value></field>");
 
                Xml.Append("<field var='Module'><value>");
                
                if (!(Event.Module is null))
                    Xml.Append(XML.Encode(Event.Module));
 
                Xml.Append("</value></field>");
                Xml.Append("<field var='StackTrace'><value>");
                
                if (!(Event.StackTrace is null))
                    Xml.Append(XML.Encode(Event.StackTrace));
 
                Xml.Append("</value></field>");
 
                if (!(Event.Tags is null))
                {
                    foreach (PersistedTag Tag in Event.Tags)
                    {
                        if (!(Tag.Name is null))
                        {
                            if (!Headers.ContainsKey(Tag.Name))
                            {
                                Headers[Tag.Name] = Tag.Name;
                                HeadersOrdered.Add(new KeyValuePair<string, string>(Tag.Name, Tag.Name));
                            }
                        }
 
                        Xml.Append("<field var='");
 
                        if (!(Tag.Name is null))
                            Xml.Append(XML.Encode(Tag.Name));
 
                        Xml.Append("'><value>");
                        
                        if (!(Tag.Value is null))
                            Xml.Append(XML.Encode(Tag.Value.ToString()));
 
                        Xml.Append("</value></field>");
                    }
                }
 
                Xml.Append("</item>");
            }
 
            StringBuilder Xml2 = new StringBuilder();
 
            Xml2.Append("<query xmlns='");
            Xml2.Append(NamespaceSearch);
            Xml2.Append("'><x xmlns='");
            Xml2.Append(NamespaceDataForm);
            Xml2.Append("' type='result'><field type='hidden' var='FORM_TYPE'><value>");
            Xml2.Append(NamespaceSearch);
            Xml2.Append("</value></field><reported>");
 
            foreach (KeyValuePair<string, string> Header in HeadersOrdered)
            {
                Xml2.Append("<field var='");
                Xml2.Append(XML.Encode(Header.Key));
                Xml2.Append("' label='");
                Xml2.Append(XML.Encode(Header.Value));
                Xml2.Append("' type='text-single'/>");
            }
 
            Xml2.Append("</reported>");
            Xml2.Append(Xml.ToString());
            Xml2.Append("</x></query>");
 
            await e.IqResult(Xml2.ToString(), e.To);
        }
 
    }
}