implab/ImplabNet Commit - r43:7c2369f580b8

improved tracing, TextListenerBase can be bound to logical operation scope.

cin -

r43:7c2369f580b8 default

parent child

Context file:

r43:7c2369f580b8

Collapse all files

Implab/Diagnostics/ConsoleTraceListener.cs +10 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class ConsoleTraceListener: TextListenerBase {
                     static readonly object _consoleLock = new object();
+                    public ConsoleTraceListener()
+                        : base(true) {
+                    }
+                    public ConsoleTraceListener(bool local)
+                        : base(local) {
+                    }
                     protected override void WriteEntry(TraceContext context, EventText text) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < text.indent; i++)
                             msg.Append("  ");
                         msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
                         lock (_consoleLock) {
                             Console.ForegroundColor = (ConsoleColor)(context.ThreadId % 15 + 1);
                             Console.WriteLine(msg.ToString());
                         }
                     }
                 }
             }

Implab/Diagnostics/TextFileListener.cs +1 -1

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class TextFileListener: TextListenerBase {
                     readonly TextWriter m_textWriter;
-                    public TextFileListener(string fileName) {
+                    public TextFileListener(string fileName) : base(true) {
                         m_textWriter = File.CreateText(fileName);
                         m_textWriter.WriteLine("LOG {0}", DateTime.Now);
                         Register(this);
                     }
                     protected override void WriteEntry(TraceContext context, EventText text) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < text.indent; i++)
                             msg.Append("  ");
                         msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
                         lock (m_textWriter) {
                             if (!IsDisposed) {
                                 m_textWriter.WriteLine(msg.ToString());
                                 m_textWriter.Flush();
                             }
                         }
                     }
                     protected override void Dispose(bool disposing) {
                         base.Dispose(disposing);
                         if (disposing) {
                             lock (m_textWriter) {
                                 Safe.Dispose(m_textWriter);
                             }
                         }
                     }
                 }
             }

Implab/Diagnostics/TextListenerBase.cs +22 -2

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public abstract class TextListenerBase : ServiceLocator, IEventTextFormatter<object>, IEventTextFormatter<TraceEvent> {
                     readonly Dictionary<object, Action> m_subscriptions = new Dictionary<object, Action>();
+                    readonly LogicalOperation m_boundOperation;
+                    readonly int m_baseIndent;
-                    protected TextListenerBase() {
+                    protected TextListenerBase(bool local) {
                         Register(this);
+                        if (local) {
+                            m_boundOperation = TraceContext.Current.CurrentOperation;
+                            m_baseIndent = Math.Max(0, m_boundOperation.Level - 1);
+                        }
                     }
                     public void Subscribe(Type eventType) {
                         if (eventType == null)
                             throw new ArgumentNullException("eventType");
                         GetType().GetMethod("Subscribe", new Type[0]).MakeGenericMethod(eventType).Invoke(this, null);
                     }
                     public void Subscribe<TEvent>() {
                         Subscribe<TEvent>(LogChannel<TEvent>.Default);
                     }
                     public void Subscribe<TEvent>(LogChannel<TEvent> channel) {
                         if (channel == null)
                             throw new ArgumentNullException("channel");
                         lock (m_subscriptions) {
                             AssertNotDisposed();
                             var formatter = GetService<IEventTextFormatter<TEvent>>();
                             EventHandler<ValueEventArgs<TEvent>> handler = (sender, args) => {
-                                WriteEntry((TraceContext)sender, formatter.Format((TraceContext)sender, args.Value));
+                                TraceContext context = (TraceContext)sender;
+                                var text = formatter.Format(context, args.Value);
+                                text.indent -= m_baseIndent;
+                                if (IsRelated(context.CurrentOperation))
+                                    WriteEntry(context, text);
                             };
                             if (m_subscriptions.ContainsKey(channel))
                                 return;
                             channel.Events += handler;
                             Action unsubscribe = () => {
                                 channel.Events -= handler;
                             };
                             m_subscriptions.Add(channel, unsubscribe);
                         }
                     }
+                    public bool IsRelated(LogicalOperation op) {
+                        if (m_boundOperation == null)
+                            return true;
+                        while (op != m_boundOperation && op.Level > m_boundOperation.Level)
+                            op = op.Parent;
+                        return op == m_boundOperation;
+                    }
                     public void Unsubscribe<TEvent>(LogChannel<TEvent> channel) {
                         if (channel == null)
                             throw new ArgumentNullException("channel");
                         lock (m_subscriptions) {
                             Action subscription;
                             if (m_subscriptions.TryGetValue(channel, out subscription)) {
                                 subscription();
                                 m_subscriptions.Remove(channel);
                             }
                         }
                     }
                     public void UnsubscribeAll() {
                         lock (m_subscriptions) {
                             foreach (var subscription in m_subscriptions.Values)
                                 subscription();
                             m_subscriptions.Clear();
                         }
                     }
                     protected abstract void WriteEntry(TraceContext context, EventText text);
                     public EventText Format(TraceContext context, object data) {
                         return new EventText {
                             indent = context.CurrentOperation.Level,
                             content = data.ToString()
                         };
                     }
                     public EventText Format(TraceContext context, TraceEvent data) {
                         var level = context.CurrentOperation.Level;
                         if (data.EventType == TraceEventType.OperationCompleted || data.EventType == TraceEventType.OperationStarted)
                             level--;
                         return new EventText {
                             indent = level,
                             content = data.ToString()
                         };
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing) {
                             UnsubscribeAll();
                         }
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/Diagnostics/TraceContext.cs +9 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Контекст трассировки, привязывается к потоку и содержит в себе информацию о стеке логических операций.
                 /// </summary>
                 /// <remarks>
                 /// Контекст трассировки передается слушателям событий для определения места, где возникло событие.
                 /// </remarks>
                 public class TraceContext {
                     LogicalOperation m_currentOperation;
                     readonly LogicalOperation m_bound;
                     readonly int m_threadId;
                     [ThreadStatic]
                     static TraceContext _current;
                     /// <summary>
                     /// Текущий контекст трассировки для потока, создается астоматически при первом обращении.
                     /// </summary>
                     public static TraceContext Current {
                         get {
                             if (_current == null)
                                 _current = new TraceContext();
                             return _current;
                         }
                     }
                     TraceContext(TraceContext context) {
                         if (context == null)
                             throw new ArgumentNullException("context");
                         m_currentOperation = context.CurrentOperation;
                         m_bound = context.CurrentOperation;
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
                     }
                     TraceContext() {
                         m_currentOperation = new LogicalOperation();
                         m_bound = m_currentOperation;
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
                     }
                     /// <summary>
                     /// При необходимости копирует состояние контекста трассивровки в текущий поток.
                     /// </summary>
                     /// <param name="from">Исходный контекст трассировки, который передается.</param>
                     /// <remarks>
                     /// <para>
                     /// Копирование происходит за счет создания нового контекста трассировки и заполнением его
                     /// состояния из переданного контекста. При этом копируется стек операций, однако в новом
                     /// контексте ранее начатые логические операции не могут быть завершены.
                     /// </para>
                     /// <para>
                     /// Если передача состояния состоялась, то вызывается событие трассировки <see cref="TraceEventType.Transfer"/>.
                     /// </para>
                     /// </remarks>
                     public static void Transfer(TraceContext from) {
                         if (_current == from)
                             return;
                         if (from != null) {
                             var context = new TraceContext(from);
                             context.LogEvent(TraceEventType.Transfer, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);
                             _current = context;
                         } else {
                             _current = new TraceContext();
                         }
                     }
                     /// <summary>
                     /// Создает постоянную копию текущего контекста, данную копию можно хранить и использовать для передачи через <see cref="Transfer(TraceContext)"/>
                     /// </summary>
                     /// <returns>Копия текущего контекста трассировки.</returns>
                     public static TraceContext Snapshot() {
                         return _current == null ? new TraceContext() : new TraceContext(_current);
                     }
                     /// <summary>
                     /// Выполняет переданное действие в указанном контексте трассировки, по окончании восстанавливает предыдущий контекст трассировки потока.
                     /// </summary>
                     /// <param name="action"></param>
                     public void Invoke(Action action) {
                         if (action == null)
                             throw new ArgumentNullException("action");
                         var old = _current;
                         Transfer(this);
                         try {
                             action();
                         } finally {
+                            _current.EndAllOperations();
                             _current = old;
                         }
                     }
                     /// <summary>
                     /// Текущая логическая операция.
                     /// </summary>
                     public LogicalOperation CurrentOperation {
                         get {
                             return m_currentOperation;
                         }
                     }
                     /// <summary>
                     /// Операция ниже которой нельзя опускаться в стеке логических операций, т.е. она не может быть завершена в текущем контексте.
                     /// </summary>
                     public LogicalOperation BoundOperation {
                         get {
                             return m_bound;
                         }
                     }
                     /// <summary>
                     /// Поток, в котором создан контекст трассировки.
                     /// </summary>
                     public int ThreadId {
                         get {
                             return m_threadId;
                         }
                     }
                     /// <summary>
                     /// Начинает безымянную логическую операцию.
                     /// </summary>
                     public void StartLogicalOperation() {
                         StartLogicalOperation(null);
                     }
                     /// <summary>
                     /// Начинает логическую операцию с указанным именем. Созданная операция будет добвалена в стек логических операций контекста, затем будет создано соответсвующее событие.
                     /// </summary>
                     /// <param name="name">Имя начинаемой операции.</param>
                     public void StartLogicalOperation(string name) {
                         m_currentOperation = new LogicalOperation(name, m_currentOperation);
                         LogEvent(TraceEventType.OperationStarted, name);
                     }
                     /// <summary>
                     /// Заканчивает логическую операцию начатую в текущем контексте. Операции, начатые в других контекстах не могут быть закончены в текущем контексте.
                     /// </summary>
                     /// <remarks>
                     /// При вызове данного метода создается событие журнала трассировки, либо о завершении операции, либо об ошибки, поскольку данная операция
                     /// начата в другом контексте.
                     /// </remarks>
                     public void EndLogicalOperation() {
                         if (m_bound == m_currentOperation) {
                             LogEvent(TraceEventType.Error, "Trying to end the operation which isn't belongs to current trace");
                         } else {
                             var op = m_currentOperation;
                             LogEvent(TraceEventType.OperationCompleted, "{0} {1} ms", op.Name, op.Duration);
                             m_currentOperation = m_currentOperation.Parent;
                         }
                     }
+                    /// <summary>
+                    /// Заврешает все начатые в этом контексте операции
+                    /// </summary>
+                    public void EndAllOperations() {
+                        while (m_bound != m_currentOperation)
+                            EndLogicalOperation();
+                    }
                     void LogEvent(TraceEventType type, string format, params object[] args) {
                         LogChannel<TraceEvent>.Default.LogEvent(this, TraceEvent.Create(type, format, args));
                     }
                 }
             }

Implab/Diagnostics/TraceEvent.cs +1 -1

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class TraceEvent {
                     public string Message {
                         get;
                         private set;
                     }
                     public TraceEventType EventType {
                         get;
                         private set;
                     }
                     public TraceEvent(TraceEventType type, string message) {
                         EventType = type;
                         Message = message;
                     }
                     public override string ToString() {
                         return String.Format("{0}: {1}", EventType, Message);
                     }
                     public static TraceEvent Create(TraceEventType type, string format, params object[] args) {
-                        return new TraceEvent(type, String.Format(format ?? String.Empty, args));
+                        return new TraceEvent(type, format == null ? String.Empty : String.Format(format, args));
                     }
                 }
             }

Implab.v11.suo removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages