Exemple #1
0
 /// <summary>
 /// Raises a log message received event.
 /// </summary>
 /// <param name="e">
 /// The event args. 
 /// </param>
 private void OnLogMessageReceived(LogMessageEventArgs e)
 {
     if (this.LogMessageReceived != null)
     {
         this.LogMessageReceived(this, e);
     }
 }
Exemple #2
0
 /// <summary>
 /// Handles a log message being recieved.
 /// </summary>
 /// <param name="sender">
 /// The sender of the event. 
 /// </param>
 /// <param name="e">
 /// The arguments of the event. 
 /// </param>
 public void LogMessageReceived(object sender, LogMessageEventArgs e)
 {
     if (this.InvokeRequired)
     {
         this.Invoke(new Action(() => this.LogMessageReceived(sender, e)));
     }
     else
     {
         this.logList.Items.Add(e);
         this.logList.SelectedIndex = this.logList.Items.Count - 1;
     }
 }
Exemple #3
0
        public void Warning_MessageFormat()
        {
            LogManager.RegisterDebugListener();
            var log = new Log(typeof(int));

            LogMessageEventArgs eventArgs = null;

            log.LogMessage += (sender, e) => eventArgs = e;

            log.Warning("log message {0}", 1);

            Assert.IsNotNull(eventArgs);
            Assert.AreEqual(log, eventArgs.Log);
            Assert.AreEqual(LogEvent.Warning, eventArgs.LogEvent);
            Assert.AreEqual("[System.Int32] log message 1", eventArgs.Message);
        }
Exemple #4
0
        public void Error_Message()
        {
            LogManager.RegisterDebugListener();
            var log = new Log(typeof(int));

            LogMessageEventArgs eventArgs = null;

            log.LogMessage += (sender, e) => eventArgs = e;

            log.Error("log message");

            Assert.IsNotNull(eventArgs);
            Assert.AreEqual(log, eventArgs.Log);
            Assert.AreEqual(LogEvent.Error, eventArgs.LogEvent);
            Assert.AreEqual("[System.Int32] log message", eventArgs.Message);
        }
Exemple #5
0
        private void WriteLog(object sender, LogMessageEventArgs logmsg)
        {
            switch (logmsg.LogType)
            {
            case MqLogType.ConsumerCancelled:
                _logger.LogWarning("RabbitMQ consumer cancelled. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumerRegistered:
                _logger.LogInformation("RabbitMQ consumer registered. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumerUnregistered:
                _logger.LogWarning("RabbitMQ consumer unregistered. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumerShutdown:
                _isHealthy = false;
                _logger.LogWarning("RabbitMQ consumer shutdown. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumeError:
                _logger.LogError("Kafka client consume error. --> " + logmsg.Reason);
                break;

            case MqLogType.ServerConnError:
                _isHealthy = false;
                _logger.LogCritical("Kafka server connection error. --> " + logmsg.Reason);
                break;

            case MqLogType.ExceptionReceived:
                _logger.LogError("AzureServiceBus subscriber received an error. --> " + logmsg.Reason);
                break;

            case MqLogType.InvalidIdFormat:
                _logger.LogError("AmazonSQS subscriber delete inflight message failed, invalid id. --> " + logmsg.Reason);
                break;

            case MqLogType.MessageNotInflight:
                _logger.LogError("AmazonSQS subscriber change message's visibility failed, message isn't in flight. --> " + logmsg.Reason);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Exemple #6
0
            public void WritesMessagesWithIndent()
            {
                LogManager.AddDebugListener();
                var log = new Log(typeof(int));

                LogMessageEventArgs eventArgs = null;

                log.LogMessage += (sender, e) => eventArgs = e;

                log.Indent();
                log.Info("Indented message");

                Assert.IsNotNull(eventArgs);
                Assert.AreEqual(log, eventArgs.Log);
                Assert.AreEqual(LogEvent.Info, eventArgs.LogEvent);
                Assert.AreEqual("  Indented message", eventArgs.Message);
            }
Exemple #7
0
            public void Info_ExceptionWithMessage()
            {
                LogManager.AddDebugListener();
                var log = new Log(typeof(int));

                LogMessageEventArgs eventArgs = null;

                log.LogMessage += (sender, e) => eventArgs = e;

                var exception = new ArgumentNullException("log test");

                log.Info(exception, "additional message");

                Assert.IsNotNull(eventArgs);
                Assert.AreEqual(log, eventArgs.Log);
                Assert.AreEqual(LogEvent.Info, eventArgs.LogEvent);
                Assert.AreEqual(string.Format("additional message | {0} (Parameter 'log test')", ArgumentNullExceptionText), eventArgs.Message);
            }
Exemple #8
0
        public void Debug_ExceptionWithMessage()
        {
            LogManager.RegisterDebugListener();
            var log = new Log(typeof(int));

            LogMessageEventArgs eventArgs = null;

            log.LogMessage += (sender, e) => eventArgs = e;

            var exception = new ArgumentNullException("log test");

            log.Debug(exception, "additional message");

            Assert.IsNotNull(eventArgs);
            Assert.AreEqual(log, eventArgs.Log);
            Assert.AreEqual(LogEvent.Debug, eventArgs.LogEvent);
            Assert.AreEqual(string.Format("[System.Int32] additional message | {0}\r\nParameter name: log test", ArgumentNullExceptionText), eventArgs.Message);
        }
Exemple #9
0
            public void Error_ExceptionWithMessageFormat()
            {
                LogManager.AddDebugListener();
                var log = new Log(typeof(int));

                LogMessageEventArgs eventArgs = null;

                log.LogMessage += (sender, e) => eventArgs = e;

                var exception = new ArgumentNullException("log test");

                log.Error(exception, "additional message {0}", 1);

                Assert.IsNotNull(eventArgs);
                Assert.AreEqual(log, eventArgs.Log);
                Assert.AreEqual(LogEvent.Error, eventArgs.LogEvent);
                Assert.AreEqual(string.Format("additional message 1 | {0}\r\nParameter name: log test", ArgumentNullExceptionText), eventArgs.Message);
            }
Exemple #10
0
            public void Warning_Exception()
            {
                LogManager.AddDebugListener();
                var log = new Log(typeof(int));

                LogMessageEventArgs eventArgs = null;

                log.LogMessage += (sender, e) => eventArgs = e;

                var exception = new ArgumentNullException("log test");

                log.Warning(exception);

                Assert.IsNotNull(eventArgs);
                Assert.AreEqual(log, eventArgs.Log);
                Assert.AreEqual(LogEvent.Warning, eventArgs.LogEvent);
                Assert.AreEqual(string.Format("{0}\r\nParameter name: log test", ArgumentNullExceptionText), eventArgs.Message);
            }
Exemple #11
0
 //print out logs - could also be done after all is said and done, ignoring this event
 private static void ClientOnLogMessageReceived(object sender, LogMessageEventArgs eventArgs)
 {
     Console.WriteLine("");
     Console.WriteLine("Log messages:");
     foreach (var msg in eventArgs.ReadMessages())
     {
         Console.WriteLine(msg);
     }
     Console.WriteLine("");
     if (null != eventArgs.LastLogPollingException)
     {
         Console.WriteLine(@"Error at {0} on {1} as: {2}",
                           eventArgs.LastLogPollingExceptionTime,
                           eventArgs.LastLogPollingExceptionServer,
                           eventArgs.LastLogPollingException);
         Console.WriteLine("");
     }
 }
Exemple #12
0
        void ListViewSelectionChanged(object sender, EventArgs e)
        {
            logView.Clear();

            int row = listView.SelectedRow;

            if (row < 0)
            {
                return;
            }

            LogMessageEventArgs logMessage = listStore.GetValue(row, logMessageField);

            if (logMessage != null)
            {
                logView.WriteText(null, logMessage.Message);
            }
        }
        private Task OnExceptionReceived(ExceptionReceivedEventArgs args)
        {
            var context          = args.ExceptionReceivedContext;
            var exceptionMessage =
                $"- Endpoint: {context.Endpoint}" + Environment.NewLine +
                $"- Entity Path: {context.EntityPath}" + Environment.NewLine +
                $"- Executing Action: {context.Action}" + Environment.NewLine +
                $"- Exception: {args.Exception}";

            var logArgs = new LogMessageEventArgs
            {
                LogType = MqLogType.ExceptionReceived,
                Reason  = exceptionMessage
            };

            OnLog?.Invoke(null, logArgs);

            return(Task.CompletedTask);
        }
Exemple #14
0
        public static void Log(object sender, LogMessageEventArgs e)
        {
            string consoleMsg = $"[{ e.Severity }] [{e.Source}] {e.Message}";

            if (e.Message == "Disconnected")
            {
                Program.isConnected = false;
            }

            if (e.Message == "Connected" && Program.isConnected)
            {
                Program._client.FindServers(Definitions.ServerDefinitions.ServerName.GetStringValue())
                .FirstOrDefault().TextChannels
                .SingleOrDefault(x => x.Name.Contains(Definitions.TextChannels.ChatNChill.GetStringValue()))
                .SendMessage(consoleMsg);
            }

            Console.WriteLine(consoleMsg);
        }
Exemple #15
0
            public void WorksWithoutData()
            {
                LogManager.AddDebugListener();
                var log = new Log(typeof(int));

                LogMessageEventArgs eventArgs = null;

                log.LogMessage += (sender, e) => eventArgs = e;

                log.InfoWithData("log message", null);

                Assert.IsNotNull(eventArgs);
                Assert.AreEqual(log, eventArgs.Log);
                Assert.AreEqual(LogEvent.Info, eventArgs.LogEvent);
                Assert.AreEqual("log message", eventArgs.Message);

                var logData = eventArgs.LogData;

                Assert.IsNull(logData);
            }
        public void PublishLogMessage(object sender, LogMessageEventArgs e)
        {
            Color  color   = e.GetMessageColor;
            string message = e.PrintedMessage;

            if (richTextBoxLogger.InvokeRequired)
            {
                DelegateLog d = new DelegateLog(PublishLogMessage);
                this.Invoke(d, new object[] { sender, e });
            }
            else
            {
                richTextBoxLogger.SelectionStart  = richTextBoxLogger.TextLength;
                richTextBoxLogger.SelectionLength = 0;
                richTextBoxLogger.SelectionColor  = color;
                richTextBoxLogger.AppendText(message);
                richTextBoxLogger.SelectionStart = richTextBoxLogger.Text.Length;
                richTextBoxLogger.ScrollToCaret();
            }
        }
Exemple #17
0
        public void LogMessageEvent()
        {
            LogManager.ClearListeners();

            var listener = new DebugLogListener();

            LogManager.AddListener(listener);

            LogMessageEventArgs eventArgs = null;

            LogManager.LogMessage += (sender, e) => eventArgs = e;

            var log = LogManager.GetLogger(typeof(LogManager));

            log.Info("hello there");

            Assert.IsNotNull(eventArgs);
            Assert.AreEqual(log, eventArgs.Log);
            Assert.AreEqual(LogEvent.Info, eventArgs.LogEvent);
            Assert.AreEqual("hello there", eventArgs.Message);
        }
Exemple #18
0
        public static void OnDiscordLog(object sender, LogMessageEventArgs args)
        {
            ConsoleColor messageColor = ConsoleColor.White;

            switch (args.Severity)
            {
            case LogSeverity.Error:
                messageColor = ConsoleColor.Red;
                break;

            case LogSeverity.Warning:
                messageColor = ConsoleColor.Yellow;
                break;

            case LogSeverity.Debug:
                messageColor = ConsoleColor.DarkCyan;
                break;
            }

            Log(args.Message, args.Severity.ToString(), messageColor);
        }
Exemple #19
0
            public void Error_Exception_Aggregated()
            {
                LogManager.AddDebugListener();
                var log = new Log(typeof(int));

                LogMessageEventArgs eventArgs = null;

                log.LogMessage += (sender, e) => eventArgs = e;

                var exception = new AggregateException("log test", new[]
                {
                    new ArgumentNullException("arg1"),
                    new ArgumentNullException("arg2"),
                });

                log.Error(exception);

                Assert.IsNotNull(eventArgs);
                Assert.AreEqual(log, eventArgs.Log);
                Assert.AreEqual(LogEvent.Error, eventArgs.LogEvent);
                Assert.AreEqual("[AggregateException] System.AggregateException: log test ---> System.ArgumentNullException: Value cannot be null.\r\nParameter name: arg1\r\n   --- End of inner exception stack trace ---\r\n---> (Inner Exception #0) System.ArgumentNullException: Value cannot be null.\r\nParameter name: arg1<---\r\n\r\n---> (Inner Exception #1) System.ArgumentNullException: Value cannot be null.\r\nParameter name: arg2<---\r\n", eventArgs.Message);
            }
Exemple #20
0
        private void WriteLog(object sender, LogMessageEventArgs logmsg)
        {
            switch (logmsg.LogType)
            {
            case MqLogType.ConsumerCancelled:
                _logger.LogWarning("RabbitMQ consumer cancelled. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumerRegistered:
                _logger.LogInformation("RabbitMQ consumer registered. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumerUnregistered:
                _logger.LogWarning("RabbitMQ consumer unregistered. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumerShutdown:
                _isHealthy = false;
                _logger.LogWarning("RabbitMQ consumer shutdown. --> " + logmsg.Reason);
                break;

            case MqLogType.ConsumeError:
                _logger.LogError("Kafka client consume error. --> " + logmsg.Reason);
                break;

            case MqLogType.ServerConnError:
                _isHealthy = false;
                _logger.LogCritical("Kafka server connection error. --> " + logmsg.Reason);
                break;

            case MqLogType.ExceptionReceived:
                _logger.LogError("AzureServiceBus subscriber received an error. --> " + logmsg.Reason);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        void Logging_LogMessage(object sender, LogMessageEventArgs e)
        {
            Helper.MessageType t = Helper.MessageType.General;

            switch (e.type)
            {
            case MessageType.Error:
                t = Helper.MessageType.Error;
                break;

            case MessageType.Info:
                t = Helper.MessageType.Info;
                break;

            case MessageType.Server:
                t = Helper.MessageType.Server;
                break;

            case MessageType.Warning:
                t = Helper.MessageType.Warning;
                break;
            }

            try
            {
                if (Application.Current != null)
                {
                    Application.Current.Dispatcher.BeginInvoke(new Action <CWSRestart.Helper.LogMessage>((m) => LogControl.Messages.Add(m)), new CWSRestart.Helper.LogMessage(e.message, t));
                }
            }
            catch (NullReferenceException)
            {
                if (Debugger.IsAttached)
                {
                    Debugger.Break();
                }
            }
        }
 private async Task ConsumeMessages(IAsyncEnumerable <RedisStream[]> streamsSet, RedisValue position)
 {
     await foreach (var set in streamsSet)
     {
         foreach (var stream in set)
         {
             foreach (var entry in stream.Entries)
             {
                 if (entry.IsNull)
                 {
                     return;
                 }
                 try
                 {
                     var message = RedisMessage.Create(entry, _groupId);
                     OnMessageReceived?.Invoke((stream.Key.ToString(), _groupId, entry.Id.ToString()), message);
                 }
                 catch (Exception ex)
                 {
                     _logger.LogError(ex.Message, ex);
                     var logArgs = new LogMessageEventArgs
                     {
                         LogType = MqLogType.ConsumeError,
                         Reason  = ex.ToString()
                     };
                     OnLog?.Invoke(entry, logArgs);
                 }
                 finally
                 {
                     var positionName = position == StreamPosition.Beginning
                 ? nameof(StreamPosition.Beginning)
                 : nameof(StreamPosition.NewMessages);
                     _logger.LogDebug($"Redis stream entry [{entry.Id}] [position : {positionName}] was delivered.");
                 }
             }
         }
     }
 }
Exemple #23
0
        public ICollection <string> FetchTopics(IEnumerable <string> topicNames)
        {
            if (topicNames == null)
            {
                throw new ArgumentNullException(nameof(topicNames));
            }

            var regexTopicNames = topicNames.Select(Helper.WildcardToRegex).ToList();

            try
            {
                var config = new AdminClientConfig(_kafkaOptions.MainConfig)
                {
                    BootstrapServers = _kafkaOptions.Servers
                };

                using var adminClient = new AdminClientBuilder(config).Build();

                adminClient.CreateTopicsAsync(regexTopicNames.Select(x => new TopicSpecification
                {
                    Name = x
                })).GetAwaiter().GetResult();
            }
            catch (CreateTopicsException ex) when(ex.Message.Contains("already exists"))
            {
            }
            catch (Exception ex)
            {
                var logArgs = new LogMessageEventArgs
                {
                    LogType = MqLogType.ConsumeError,
                    Reason  = $"An error was encountered when automatically creating topic! -->" + ex.Message
                };
                OnLog?.Invoke(null, logArgs);
            }

            return(regexTopicNames);
        }
Exemple #24
0
        private void WriteLog(object sender, LogMessageEventArgs logmsg)
        {
            switch (logmsg.EventType)
            {
            case EventType.ConsumerCancelled:
                _logger.LogWarning("RabbitMQ consumer cancelled. --> " + logmsg.Reason);
                break;

            case EventType.ConsumerRegistered:
                _logger.LogInformation("RabbitMQ consumer registered. --> " + logmsg.Reason);
                break;

            case EventType.ConsumerUnregistered:
                _logger.LogWarning("RabbitMQ consumer unregistered. --> " + logmsg.Reason);
                break;

            case EventType.ConsumerShutdown:
                _logger.LogWarning("RabbitMQ consumer shutdown. --> " + logmsg.Reason);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Exemple #25
0
        void LogDispatcherOnMessageLogged(object sender, LogMessageEventArgs logMessageEventArgs)
        {
            if (logMessageEventArgs.Level == "Trace" && logMessageEventArgs.Message.StartsWith("Messages loaded: #"))
            {
                this.Text = logMessageEventArgs.Message;

                return;
            }

            var date = DateTime.Now.ToString(CultureInfo.InvariantCulture);

            lvwLog.BeginInvoke((Action)(() =>
            {
                var item = lvwLog.Items.Add
                           (
                    new ListViewItem
                    (
                        new[] { date, logMessageEventArgs.Level, logMessageEventArgs.Message }
                    )
                           );

                lvwLog.EnsureVisible(item.Index);
            }));
        }
Exemple #26
0
        void AddLogMessage(LogMessageEventArgs e)
        {
            int row = 0;

            if (listStore.RowCount == 0)
            {
                row = listStore.AddRow();
            }
            else
            {
                row = listStore.InsertRowBefore(0);
            }

            listStore.SetValues(
                row,
                iconField,
                GetIcon(e.Level),
                logMessageTypeField,
                GetTypeName(e.Level),
                logMessageTextField,
                GetListMessage(e.Message),
                logMessageField,
                e);
        }
 void HandleLogMessage(LogMessageEventArgs args)
 {
     ShowChatText(args.Message);
 }
Exemple #28
0
 private void Log(object sender, LogMessageEventArgs e)
 {
     Console.WriteLine($"[{e.Source}] [{e.Message}]");
 }
		/// <summary>
		/// Log the message e.MessageRaises the log message event.
		/// </summary>
		/// <param name="sender">Sender.</param>
		/// <param name="e">Event arguments.</param>
		public void OnLogMessage (Object sender, LogMessageEventArgs e)
		{
			if (e.Level <= logLevel)
			{
				if (logFile != null)
				{
					// Create log entry
					logFile.WriteLine (engine.CreateLogMessage (e.Message));
				}
			}
		}
		/// <summary>
		/// Log the message e.MessageRaises the log message event.
		/// </summary>
		/// <param name="sender">Sender.</param>
		/// <param name="e">Event arguments.</param>
		public void OnLogMessage (Object sender, LogMessageEventArgs args)
		{
			if (args.Level <= logLevel)
			{
				// TODO: Remove
				Console.WriteLine (engine.CreateLogMessage (args.Message));

				if (logFile != null)
				{
					// Create log entry
					logFile.WriteLine (engine.CreateLogMessage (args.Message));
				}
			}
		}
		private void WFCoreAdapter_LogMessageRequested(object sender, LogMessageEventArgs e)
		{
			LogDebug(String.Format("[{0}]: {1}", e.Level, e.Message), e.Level);
		}
Exemple #32
0
 /// <summary>
 /// Handles a log message being recieved.
 /// </summary>
 /// <param name="sender">
 /// The sender of the event. 
 /// </param>
 /// <param name="e">
 /// The arguments of the event. 
 /// </param>
 private void OnLogMessageReceived(object sender, LogMessageEventArgs e)
 {
     // Cache the messages in a list until the controller has been initialised.
     // Then the message can be sent directly to the view.
     if (!this.initialised)
     {
         this.Log.Add(e);
     }
     else
     {
         this.OnLogMessageReceived(e);
     }
 }
Exemple #33
0
        //public void Log(object sender, LogMessageEventArgs e)
        //{
        //    Console.WriteLine($"[{e.Severity}] [{e.Source}] {e.Message}");
        //}

        public void Log(object sender, LogMessageEventArgs e)
        {
            Console.WriteLine("Log disabled");
        }
 private void OnLogListenerLogMessage(object sender, LogMessageEventArgs e)
 {
     LogMessage.SafeInvoke(this, e);
 }
Exemple #35
0
        private static void HandleLogMessage(object sender, LogMessageEventArgs e)
        {
            try
            {
                if (e != null)
                {
                    //Create log item
                    string logItem;
                    DateTime now = DateTime.Now;
                    string message = "";
                    if (e.Exception != null)
                        message = string.Format("EXCEPTION:{0}{1}{0}Source: {2}{0}Message: {3}{0}Stack trace: {4}{0}{1}",
                                                System.Environment.NewLine,
                                                "-----------------------------------------------------------------------------",
                                                e.Exception.Source,
                                                e.Exception.Message,
                                                e.Exception.StackTrace);
                    else
                        message = e.Message;
                    if (sender is IUnique)
                    {
                        IUnique unique = (IUnique)sender;
                        logItem = string.Format("{0} ({1}-{2}): {3}", AddinManager.CurrentLocalizer.GetString(e.LogLevel.ToString()), now, unique.Key, message);
                    }
                    else
                        logItem = string.Format("{0} ({1}): {2}", AddinManager.CurrentLocalizer.GetString(e.LogLevel.ToString()), now, message);

                    //Show in console
                    Console.WriteLine(logItem);

                    //Write to file
                    WriteLogItem(logItem, now);
                }
            }
            catch { }
        }
Exemple #36
0
 private void realCore_LogMessageGenerated(object sender, LogMessageEventArgs e)
 {
     if (LogMessageGenerated != null)
     {
         LogMessageGenerated(this, e);
     }
 }
 private void Ui_MessageLogged(object sender, LogMessageEventArgs e)
 {
     this.Log(e.Level, e.Message);
 }
Exemple #38
0
		/// <summary>
		/// Raises the log message event.
		/// </summary>
		/// <param name="sender">Sender of event.</param>
		/// <param name="args">Log message event arguments.</param>
		public void OnLogMessage(object sender, LogMessageEventArgs args)
		{
			this.LogMessage(args.Level, args.Message);
		}
Exemple #39
0
 private void Log(object sender, LogMessageEventArgs e)
 {
     Console.WriteLine(e.Message);
 }
Exemple #40
0
 private void OnLogMessage(object sender, LogMessageEventArgs e) => _ui.LogMessage(e.message, e.type);
Exemple #41
0
        //Helper methods
        private void LogMessage(string message, bool forVerboseOnly)
        {
            LogMessageEventArgs e = new LogMessageEventArgs();
            e.errorMessage = message;
            e.verboseMessage = forVerboseOnly;
            e.kinectID = kinectID;

            if (LogMessageGenerated != null)
            {
                LogMessageGenerated(this, e);
            }
        }
 private void LogHandler(object sender, LogMessageEventArgs logMessageEventArgs)
 {
     Console.WriteLine(logMessageEventArgs.Message + " (" + logMessageEventArgs.Severity + ") [" + logMessageEventArgs.Source + "]");
 }
Exemple #43
0
 private void OnLogMessage(object sender, LogMessageEventArgs e)
 {
     _dispatcherService.BeginInvoke(() =>
     {
         var traceEntries = TraceEntries;
         if (traceEntries != null)
         {
             var traceEntry = new TraceEntry(new LogEntry(e));
             TraceEntries.Add(traceEntry);
         }
     });
 }
Exemple #44
0
 public void HandleLogMessage(object sender, LogMessageEventArgs logEvent)
 {
     _log.Write(logEvent.Severity.ToLogLevel(), "Discord Client: {0}", logEvent.Message);
 }
Exemple #45
0
 /// <summary>
 /// Handles the receipt of a log message.
 /// </summary>
 /// <param name="sender">
 /// The sender of the event.
 /// </param>
 /// <param name="e">
 /// The arguments of the event.
 /// </param>
 private void OnLogMessage(object sender, LogMessageEventArgs e)
 {
     this.Invoke(new Action(() => this.log.TopIndex = this.log.Items.Add(e.ToString())));
 }