public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
 {
     if ((this.Filter == null) || this.Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null))
     {
         this.WriteLine(message);
     }
 }

			private static LogLevels? ToStockSharp(TraceEventType eventType)
			{
				switch (eventType)
				{
					case TraceEventType.Critical:
					case TraceEventType.Error:
						return LogLevels.Error;

					case TraceEventType.Warning:
						return LogLevels.Warning;

					case TraceEventType.Information:
						return LogLevels.Info;

					case TraceEventType.Verbose:
						return LogLevels.Debug;

					case TraceEventType.Start:
					case TraceEventType.Stop:
					case TraceEventType.Suspend:
					case TraceEventType.Resume:
					case TraceEventType.Transfer:
						return null;
					default:
						throw new ArgumentOutOfRangeException("eventType");
				}
			}

 static Level DefaultGetLogLevel(TraceEventType traceEventType)
 {
     switch (traceEventType)
     {
         case TraceEventType.Critical:
             return Level.Fatal;
         case TraceEventType.Error:
             return Level.Error;
         case TraceEventType.Warning:
             return Level.Warn;
         case TraceEventType.Information:
             return Level.Info;
         case TraceEventType.Verbose:
             return Level.Trace;
         case TraceEventType.Start:
             return Level.Debug;
         case TraceEventType.Stop:
             return Level.Debug;
         case TraceEventType.Suspend:
             return Level.Debug;
         case TraceEventType.Resume:
             return Level.Debug;
         case TraceEventType.Transfer:
             return Level.Debug;
         default:
             throw new ArgumentOutOfRangeException("traceEventType");
     }
 }

 protected static bool DefaultIsLogEventEnabled(ILog commonLog, TraceEventType traceEventType)
 {
     switch (traceEventType)
     {
         case TraceEventType.Critical:
             return commonLog.IsFatalEnabled;
         case TraceEventType.Error:
             return commonLog.IsErrorEnabled;
         case TraceEventType.Warning:
             return commonLog.IsWarnEnabled;
         case TraceEventType.Information:
             return commonLog.IsInfoEnabled;
         case TraceEventType.Verbose:
             return commonLog.IsTraceEnabled;
         case TraceEventType.Start:
             return commonLog.IsDebugEnabled;
         case TraceEventType.Stop:
             return commonLog.IsDebugEnabled;
         case TraceEventType.Suspend:
             return commonLog.IsDebugEnabled;
         case TraceEventType.Resume:
             return commonLog.IsDebugEnabled;
         case TraceEventType.Transfer:
             return commonLog.IsDebugEnabled;
         default:
             throw new ArgumentOutOfRangeException("traceEventType");
     }
 }

 public void Log(string message, TraceEventType eventType)
 {
     foreach (ILogger logger in this.loggers)
     {
         logger.Log(message, eventType);
     }
 }

 private LogLevel Map(TraceEventType eventType)
 {
     switch (eventType)
     {
         case TraceEventType.Critical:
             return LogLevel.Fatal;
         case TraceEventType.Error:
             return LogLevel.Error;
         case TraceEventType.Warning:
             return LogLevel.Warn;
         case TraceEventType.Information:
             return LogLevel.Info;
         case TraceEventType.Verbose:
             return LogLevel.Trace;
         case TraceEventType.Start:
             return LogLevel.Info;
         case TraceEventType.Stop:
             return LogLevel.Info;
         case TraceEventType.Suspend:
             return LogLevel.Info;
         case TraceEventType.Resume:
             return LogLevel.Info;
         case TraceEventType.Transfer:
             return LogLevel.Info;
         default:
             throw new ArgumentOutOfRangeException("eventType");
     }
 }

 void Trace(TraceEventType eventType, string message)
 {
     if (this.Switch.ShouldTrace(eventType) && this.Listeners != null)
     {
         TraceEvent(eventType, 0, m_header + message);
     }
 }

 /// <summary>
 /// Determines whether a filter is attached to this listener and, if so, asks whether it ShouldTrace applies to this data.
 /// </summary>
 protected virtual bool ShouldTrace(TraceEventCache eventCache, string source, TraceEventType eventType, int id,
                                    string formatOrMessage, object[] args, object data1, object[] data)
 {
     return
         !(Filter != null &&
           !Filter.ShouldTrace(eventCache, source, eventType, id, formatOrMessage, args, data1, data));
 }

 /// <summary>
 /// Returns the value of Environment.MachineName
 /// </summary>
 /// <param name="value">The output parameter</param>
 /// <param name="cache">Unused</param>
 /// <param name="source">Unused</param>
 /// <param name="eventType">Unused</param>
 /// <param name="id">Unused</param>
 /// <param name="formatOrMessage">Unused</param>
 /// <param name="data">Unused</param>
 /// <returns>True</returns>
 public override bool TryGetValue(out object value, TraceEventCache cache, string source,
                                  TraceEventType eventType, int id, string formatOrMessage,
                                  object[] data)
 {
     value = Environment.MachineName;
     return true;
 }

 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
 {
     this.source = source;
     this.eventType = eventType;
     this.id = id;
     TraceEvent(eventCache, source, eventType, id, "No additional information.");
 }

 public DebugConsoleMessageEventArgs(DateTime timestamp, string message, TraceEventType level, string source)
 {
     Timestamp = timestamp;
     Message = message;
     Level = level;
     Source = source;
 }

 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
 {
     if (_enabled)
     {
         WebSocketHost.Send($"{eventType}:{id} - {source}");
     }
 }

 private void Trace(TraceEventType type, string message, params object[] parameters)
 {
     if (category.Source.Switch.ShouldTrace(type))
     {
         category.Source.TraceEvent(type, EVENT_ID, message, parameters);
     }
 }

        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id,
                                       params object[] data)
        {
            if (this.Filter != null &&
                !this.Filter.ShouldTrace(eventCache, source, eventType, id, string.Empty, null, null, null))
                return;

            foreach (object obj in data)
            {
                if (obj is XPathNavigator)
                {
                    using (var reader = ((XPathNavigator)obj).ReadSubtree())
                    {
                        reader.MoveToContent();
                        if (reader.IsStartElement())
                            Console.WriteLine(XElement.ReadFrom(reader).ToString(SaveOptions.OmitDuplicateNamespaces));
                        else
                        {
                            Console.WriteLine("Unable to write Xml data.");
                        }
                    }
                }
                else
                {
                    Console.WriteLine(obj.ToString());
                }
            }
        }

        private static EventLevel GetLogLevel(TraceEventType traceEventType)
        {
            switch (traceEventType)
            {
                case TraceEventType.Critical:
                    return EventLevel.Critical;

                case TraceEventType.Error:
                    return EventLevel.Error;

                case TraceEventType.Warning:
                    return EventLevel.Warning;

                case TraceEventType.Information:
                    return EventLevel.Informational;

                case TraceEventType.Verbose:
                case TraceEventType.Start:
                case TraceEventType.Stop:
                case TraceEventType.Suspend:
                case TraceEventType.Resume:
                case TraceEventType.Transfer:
                    return EventLevel.Verbose;

                default:
                    throw new ArgumentOutOfRangeException(nameof(traceEventType));
            }
        }

 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
 {
     var te = new TraceEvent {Cache = eventCache, Source = source, Type = eventType, Id = id};
     Events.Add(te);
     if (OnEventAdd != null)
         OnEventAdd.Invoke(te);
 }

 internal MyLoggingExceptionHandler(string logCategory, int eventId, TraceEventType severity, string title, int priority, 
     Type formatterType, LogWriter writer, DocumentModel doc)
     : base(logCategory, eventId, severity, title, priority, formatterType, writer)
 {
     this.m_Writer = writer;
     this.doc = doc;
 }

 public override sealed void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data)
 {
     if ((base.Filter == null) || base.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, null, data))
     {
         WriteTrace(eventCache, source, eventType, id, null, null, data);
     }
 }

 LogLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType)
 {
     Name = name;
     _index = index;
     SourceLevel = sourceLevel;
     TraceEventType = traceEventType;
 }

 public override sealed void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
 {
     if ((base.Filter == null) || base.Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null))
     {
         WriteTrace(eventCache, source, eventType, id, message, null, null);
     }
 }