LogFunction.cs

using System;
using System.Collections.Generic;
using Waher.Events;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
 
namespace Waher.Script.Functions.Logging
{
    public abstract class LogFunction : FunctionMultiVariate
    {
        public LogFunction(ScriptNode Message, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Message }, new ArgumentType[] { ArgumentType.Scalar }, Start, Length, Expression)
        {
        }
 
        public LogFunction(ScriptNode Message, ScriptNode Tags, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Message, Tags }, new ArgumentType[] { ArgumentType.Scalar, ArgumentType.Normal },
                  Start, Length, Expression)
        {
        }
 
        public override string[] DefaultArgumentNames => new string[] { "Message" };
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            object M = Arguments[0].AssociatedObjectValue;
            string Object = string.Empty;
            string Actor = string.Empty;
            string EventId = string.Empty;
            string Facility = string.Empty;
            string Module = string.Empty;
            string StackTrace = string.Empty;
            EventLevel Level = EventLevel.Minor;
            ChunkedList<KeyValuePair<string, object>> Tags = null;
            bool Detailed = false;
 
            if (!(M is string Message))
            {
                if (M is Exception ex)
                {
                    string s;
 
                    Message = ex.Message;
                    Object = ex is IEventObject Obj2 && !string.IsNullOrEmpty(s = Obj2.Object) ? s : Object;
                    Actor = ex is IEventActor Act && !string.IsNullOrEmpty(s = Act.Actor) ? s : Actor;
                    EventId = ex is IEventId EvId && !string.IsNullOrEmpty(s = EvId.EventId) ? s : EventId;
                    Level = ex is IEventLevel Lvl && Lvl.Level.HasValue ? Lvl.Level.Value : Level;
                    Facility = ex is IEventFacility EvFa && !string.IsNullOrEmpty(s = EvFa.Facility) ? s : Facility;
                    Module = ex is IEventModule Mod && !string.IsNullOrEmpty(s = Mod.Module) ? s : ex.Source;
                    StackTrace = Log.CleanStackTrace(ex.StackTrace);
 
                    if (ex is IEventTags Tags2)
                    {
                        KeyValuePair<string, object>[] Tags3 = Tags2.Tags;
                        if (!(Tags3 is null))
                        {
                            Tags = new ChunkedList<KeyValuePair<string, object>>();
                            Tags.AddRange(Tags3);
                        }
                    }
 
                    Detailed = true;
                }
                else
                    Message = M?.ToString() ?? string.Empty;
            }
 
            if (Arguments.Length > 1 &&
                Arguments[1].AssociatedObjectValue is IDictionary<string, IElement> Obj)
            {
                foreach (KeyValuePair<string, IElement> P in Obj)
                {
                    switch (P.Key.ToUpper())
                    {
                        case "OBJECT":
                            Object = ToString(P.Value) ?? string.Empty;
                            break;
 
                        case "ACTOR":
                            Actor = ToString(P.Value) ?? string.Empty;
                            break;
 
                        case "EVENTID":
                            EventId = ToString(P.Value) ?? string.Empty;
                            break;
 
                        case "FACILITY":
                            Facility = ToString(P.Value) ?? string.Empty;
                            break;
 
                        case "MODULE":
                            Module = ToString(P.Value) ?? string.Empty;
                            break;
 
                        case "STACKTRACE":
                            StackTrace = ToString(P.Value) ?? string.Empty;
                            break;
 
                        case "LEVEL":
                            if (P.Value.AssociatedObjectValue is EventLevel L ||
                                Enum.TryParse(ToString(P.Value) ?? string.Empty, out L))
                            {
                                Level = L;
                            }
                            else
                            {
                                if (Tags is null)
                                    Tags = new ChunkedList<KeyValuePair<string, object>>();
 
                                Tags.Add(new KeyValuePair<string, object>(P.Key, P.Value.AssociatedObjectValue));
                            }
                            break;
 
                        default:
                            if (Tags is null)
                                Tags = new ChunkedList<KeyValuePair<string, object>>();
 
                            Tags.Add(new KeyValuePair<string, object>(P.Key, P.Value.AssociatedObjectValue));
                            break;
                    }
                }
 
                Detailed = true;
            }
 
            if (Detailed)
            {
                this.DoLog(Message, Object, Actor, EventId, Level, Facility, Module, StackTrace,
                    Tags?.ToArray() ?? Array.Empty<KeyValuePair<string, object>>());
            }
            else
                this.DoLog(Message);
 
            return Arguments[0];
        }
 
        public abstract void DoLog(string Message);
 
        public abstract void DoLog(string Message, string Object, string Actor, string EventId, EventLevel Level,
            string Facility, string Module, string StackTrace, params KeyValuePair<string, object>[] Tags);
    }
}