public FilterEditorDialog(LogMessage message, LogMessageFilter filter) { if (message == null) throw new ArgumentNullException(nameof(message)); if (filter == null) throw new ArgumentNullException(nameof(filter)); m_sampleMessage = message; m_filter = new LogMessageFilter(); m_filter.FilterLevel = filter.FilterLevel; m_filter.TimeFilter = filter.TimeFilter ?? new TimestampMatching(TimestampMatchingMode.Inside, message.UtcTime.AddMinutes(-1), message.UtcTime.AddMinutes(1)); m_filter.Classification = filter.Classification ?? new EnumMatchingFlags(EnumMatchingFlagsMode.Any, 1 << (int)message.Classification, message.Classification.ToString()); m_filter.Level = filter.Level ?? new EnumMatchingFlags(EnumMatchingFlagsMode.Any, 1 << (int)message.Level, message.Level.ToString()); m_filter.Flags = filter.Flags ?? new EnumMatchingFlags(EnumMatchingFlagsMode.All, (int)message.Flags, message.Flags.ToString()); m_filter.Assembly = filter.Assembly ?? new StringMatching(StringMatchingMode.Exact, message.AssemblyName); m_filter.Type = filter.Type ?? new StringMatching(StringMatchingMode.Exact, message.TypeName); m_filter.RelatedType = filter.RelatedType ?? new StringMatching(StringMatchingMode.Exact, message.TypeName); m_filter.StackDetails = filter.StackDetails ?? new StackDetailsMatching(); m_filter.StackTraceDetails = filter.StackTraceDetails ?? new StackTraceMatching(); m_filter.EventName = filter.EventName ?? new StringMatching(StringMatchingMode.Exact, message.EventName); m_filter.MessageText = filter.MessageText ?? new StringMatching(StringMatchingMode.Exact, message.Message); m_filter.DetailsText = filter.DetailsText ?? new StringMatching(StringMatchingMode.Exact, message.Details); m_filter.ExceptionText = filter.ExceptionText ?? new StringMatching(StringMatchingMode.Exact, message.ExceptionString); InitializeComponent(); chkTime.Checked = filter.TimeFilter != null; chkClass.Checked = filter.Classification != null; chkLevel.Checked = filter.Level != null; chkFlags.Checked = filter.Flags != null; chkAssembly.Checked = filter.Assembly != null; chkType.Checked = filter.Type != null; chkRelatedType.Checked = filter.RelatedType != null; chkStackDetails.Checked = filter.StackDetails != null; chkStackTrace.Checked = filter.StackTraceDetails != null; chkEventName.Checked = filter.EventName != null; chkMessage.Checked = filter.MessageText != null; chkDetails.Checked = filter.DetailsText != null; chkException.Checked = filter.ExceptionText != null; lblTime.Text = m_filter.TimeFilter.ToString(); lblClass.Text = m_filter.Classification.ToString(); lblLevel.Text = m_filter.Level.ToString(); lblFlags.Text = m_filter.Flags.ToString(); lblAssembly.Text = m_filter.Assembly.ToString(); lblType.Text = m_filter.Type.ToString(); lblRelatedType.Text = m_filter.RelatedType.ToString(); lblStackDetails.Text = m_filter.StackDetails.ToString(); lblStackTrace.Text = m_filter.StackTraceDetails.ToString(); lblEventName.Text = m_filter.EventName.ToString(); lblMessage.Text = m_filter.MessageText.ToString(); lblDetails.Text = m_filter.DetailsText.ToString(); lblException.Text = m_filter.ExceptionText.ToString(); cmbVerbose.SelectedIndex = (int)m_filter.FilterLevel; chkMessage.Checked = filter.MessageText != null; chkMessage.Tag = filter.MessageText ?? new StringMatching(StringMatchingMode.Exact, message.Message); }
/// <summary> /// Reads all log messages from the supplied file. /// </summary> public static void Compact(ICollection<string> inputFileNames, string outputFileName) { LogCollection logs = new LogCollection(); foreach (var file in inputFileNames) { using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { if (stream.ReadBoolean()) { //Wrong File Version break; } if (stream.ReadNextByte() != 1) { //Wrong File Version break; } using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress, true)) using (var bs = new BufferedStream(zipStream, 8192)) { while (bs.ReadBoolean()) { var message = new LogMessage(bs); logs.Pass1(message); } } } } logs.Compact(); foreach (var file in inputFileNames) { using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { if (stream.ReadBoolean()) { //Wrong File Version break; } if (stream.ReadNextByte() != 1) { //Wrong File Version break; } using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress, true)) using (var bs = new BufferedStream(zipStream, 8192)) { while (bs.ReadBoolean()) { var message = new LogMessage(bs); logs.Pass2(message); } } } } logs.Save(outputFileName); }
/// <summary> /// Reads all log messages from the supplied file. /// </summary> public static List<LogMessage> Read(string logFileName) { List<LogMessage> lst = new List<LogMessage>(); FilePath.ValidatePathName(logFileName); using (var stream = new FileStream(logFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) { try { LogMessageSaveHelper helper; int version = stream.ReadInt32(); switch (version) { case 282497: helper = LogMessageSaveHelper.Create(); //VersionNumber: Compressed. With LogSaveHelper break; default: throw new VersionNotFoundException(); } using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress, true)) using (var bs = new BufferedStream(zipStream)) { while (bs.ReadBoolean()) { var message = new LogMessage(bs, helper); lst.Add(message); } bs.Dispose(); } } catch (EndOfStreamException) { } catch (ZlibException) { } } return lst; }
public void Assign(LogMessage message, int keepWeight) { if (Classification != message.Classification || Level != message.Level || UtcDateTime != message.UtcTime) throw new Exception("Parsing Exception"); if (KeepWeighting >= keepWeight) { Message = message; } }
public MessageData(LogMessage message) { Classification = message.Classification; Level = message.Level; KeepWeighting = 0; UtcDateTime = message.UtcTime; message = null; }
public void Pass2(LogMessage message) { AllMessages[m_index].Assign(message, KeepWeight); m_index++; }
public bool IsMatch(LogMessage log) { if (TimeFilter != null) { if (!TimeFilter.IsMatch(log.UtcTime)) return false; } if (Classification != null) { if (!Classification.IsMatch(1 << (int)log.Classification)) return false; } if (Level != null) { if (!Level.IsMatch(1 << (int)log.Level)) return false; } if (Flags != null) { if (!Flags.IsMatch((int)log.Flags)) return false; } if (Assembly != null) { if (!Assembly.IsMatch(log.AssemblyName)) return false; } if (Type != null) { if (!Type.IsMatch(log.TypeName)) return false; } if (RelatedType != null) { if (!MatchRelatedType(log)) return false; } if (StackDetails != null) { if (!StackDetails.IsMatch(log)) return false; } if (StackTraceDetails != null) { if (!StackTraceDetails.IsMatch(log)) return false; } if (EventName != null) { if (!EventName.IsMatch(log.EventName)) return false; } if (MessageText != null) { if (!MessageText.IsMatch(log.Message)) return false; } if (DetailsText != null) { if (!DetailsText.IsMatch(log.Details)) return false; } if (ExceptionText != null) { if (!ExceptionText.IsMatch(log.ExceptionString)) return false; } return true; }
private void SubscriberNewLogMessage(LogMessage logMessage) { lock (m_syncRoot) { if (m_path == null) { LogMessage message; if (m_messageQueue.Count >= m_maxQueue) m_messageQueue.TryDequeue(out message); m_messageQueue.Enqueue(logMessage); } else { m_messageQueue.Enqueue(logMessage); m_flushTask.Start(1000); } } }
public TypeMenu(List<LogMessage> selectedLogMessages) { m_log = selectedLogMessages.First(); }
/// <summary> /// Assigns the supplied message to this subscriber. /// </summary> /// <param name="log">the message</param> public void RaiseLogMessages(LogMessage log) { if (m_disposed) return; lock (m_syncRoot) { if (m_disposed) return; if (m_allSubscriptions == null || m_allSubscriptions.Count == 0) return; OnLog(log); } }
/// <summary> /// Writes the specified log to the file /// </summary> /// <param name="log"></param> /// <param name="autoFlush"></param> public void Write(LogMessage log, bool autoFlush = true) { try { m_tmpStream.Position = 0; m_tmpStream.Write(true); log.Save(m_tmpStream, m_saveHelper); long length = m_tmpStream.Position; m_tmpStream.Position = 0; m_tmpStream.CopyTo(m_zipStream, length, m_tmpBuffer); if (log.Level >= MessageLevel.Info && autoFlush) { m_zipStream.Flush(); } m_logCount++; } catch (Exception) { throw; } }
public bool IsMatch(LogMessage log) { return true; }
private void m_logSubscriber_Log(LogMessage logMessage) { switch (logMessage.Level) { case MessageLevel.Critical: case MessageLevel.Error: ServiceHelper?.ErrorLogger?.Log(logMessage.Exception ?? new InvalidOperationException(logMessage.GetMessage())); break; case MessageLevel.Warning: DisplayStatusMessage($"[SnapEngine] WARNING: {logMessage.Message}", UpdateType.Warning, false); break; case MessageLevel.Debug: break; default: DisplayStatusMessage($"[SnapEngine] {logMessage.Message}", UpdateType.Information, false); break; } }
/// <summary> /// Raises a log message with the provided data. /// </summary> /// <param name="overriddenAttributes">attributes to use with this message</param> /// <param name="message"></param> /// <param name="details">A long text field with the details of the message.</param> /// <param name="exception">An exception object if one is provided.</param> /// <param name="initialStackMessage"></param> /// <param name="initialStackTrace"></param> public void Publish(LogMessageAttributes? overriddenAttributes, string message, string details, Exception exception, LogStackMessages initialStackMessage, LogStackTrace initialStackTrace) { if (Logger.ShouldSuppressLogMessages) return; LogMessageAttributes attributes = overriddenAttributes ?? m_attributes; if (!m_publisher.HasSubscribers(attributes)) return; if (message == null) message = string.Empty; if (details == null) details = string.Empty; var suppressionFlags = m_supressionEngine.IncrementPublishCount(); if (suppressionFlags != MessageSuppression.None) { m_messagesSuppressed++; if (ShouldRaiseMessageSupressionNotifications && m_suppressionMessageNextPublishTime <= ShortTime.Now) { m_suppressionMessageNextPublishTime = ShortTime.Now.AddSeconds(10); MessageSuppressionIndication.Publish($"Message Suppression Is Occurring To: '{ m_owner.TypeData.TypeName }' {m_messagesSuppressed.ToString()} total messages have been suppressed.", m_owner.ToString()); } attributes += suppressionFlags; if (!m_publisher.HasSubscribers(attributes)) return; } LogStackMessages currentStackMessages = Logger.GetStackMessages(); LogStackTrace currentStackTrace = LogStackTrace.Empty; if (m_stackTraceDepth > 0) { currentStackTrace = new LogStackTrace(true, 2, m_stackTraceDepth); } else if (exception != null || attributes.Level >= MessageLevel.Error) { currentStackTrace = new LogStackTrace(true, 2, 10); } var logMessage = new LogMessage(m_owner, initialStackMessage, initialStackTrace, currentStackMessages, currentStackTrace, attributes, message, details, exception); m_logger.OnNewMessage(logMessage, m_publisher); }
private void SubscriberNewLogMessage(LogMessage logMessage) { string text = "---------------------------------------------------------" + Environment.NewLine + logMessage.GetMessage() + Environment.NewLine + "---------------------------------------------------------"; System.Console.WriteLine(text); }
private bool MatchRelatedType(LogMessage log) { if (RelatedType.IsMatch(log.TypeName)) return true; foreach (var item in log.RelatedTypes) { if (RelatedType.IsMatch(item)) return true; } return false; }
void subscriber_Log(LogMessage logMessage) { Console.WriteLine(logMessage.GetMessage()); }
/// <summary> /// Handles the routing of messages through the logging system. /// </summary> /// <param name="message">the message to route</param> /// <param name="publisher">the publisher that is originating this message.</param> public void OnNewMessage(LogMessage message, LogPublisherInternal publisher) { m_messages.Enqueue(Tuple.Create(message, publisher)); m_routingTask.Start(50); //Allow a 50ms delay for multiple logs to queue if in a burst period. }
/// <summary> /// Raises the <see cref="NewLogMessage"/> event. /// </summary> /// <param name="logMessage">the message to raise.</param> private void OnLog(LogMessage logMessage) { if (logMessage == null) return; try { using (Logger.SuppressFirstChanceExceptionLogMessages()) { NewLogMessage?.Invoke(logMessage); } } catch (Exception) { //Swallow this exception //This is because if a subscriber throws an exception, creating a new log //might cause an infinite loop. } }
public void Pass1(LogMessage message) { MessageByOwner m; if (!m_owners.TryGetValue(message.EventPublisherDetails, out m)) { m = new MessageByOwner(message.EventPublisherDetails); m_owners.Add(message.EventPublisherDetails, m); } m.Pass1(message); }
public void Pass2(LogMessage message) { m_owners[message.EventPublisherDetails].Pass2(message); }
public void Pass1(LogMessage message) { AllMessages.Add(new MessageData(message)); }
private void WriteLogMessage(LogMessage log) { //Rollover a file if over 500KB in size, over 50000 records, or older than 12 hours. //Ideally, 500KB will always come first. if (m_writer != null && (m_writer.LogSize > 500 * 1024 || m_writer.LogCount >= 50000 || m_fileAge.Elapsed.TotalHours > 12)) { string fileName = m_writer.FileName; m_writer.Dispose(); m_writer = null; OnNewFileComplete(fileName); } if (m_writer == null) { m_fileAge.Restart(); try { if (m_maxFileCount > 0) { string[] files = Directory.GetFiles(m_path, "*.logz"); if (files.Length > m_maxFileCount) { Array.Sort(files); for (int x = 0; x < files.Length - m_maxFileCount; x++) { File.Delete(files[x]); } } } } catch (Exception) { } string file = $"{DateTime.UtcNow.ToString("yyyyMMdd-HHmmss-ffffff")} - {m_processName} - {m_fileSequenceNumber}.logz"; m_fileSequenceNumber++; var fileName = Path.Combine(m_path, file); m_writer = new LogFileWriter(fileName); } m_writer.Write(log, false); }
public ExceptionMenu(List<LogMessage> selectedLogMessages) { m_log = selectedLogMessages.First(); }