implab/ImplabNet Commit - r48:d9d794b61bb9

Interactive tracing...

cin -

r48:d9d794b61bb9 interactive logger

parent child

Context file:

r48:d9d794b61bb9

Collapse all files

Implab.Diagnostics.Interactive/InteractiveListener.cs +23 -8

             namespace Implab.Diagnostics.Interactive
             {
-                public class InteractiveListener: Disposable
+                public class InteractiveListener: TextListenerBase
                 {
                     TraceForm m_form;
                     SynchronizationContext m_syncGuiThread;
+                    readonly Promise<object> m_guiStarted = new Promise<object>();
                     readonly IPromiseBase m_guiFinished;
-                    readonly Promise<object> m_guiStarted = new Promise<object>();
                     readonly IPromiseBase m_workerFinished = new Promise<object>();
                     readonly MTQueue<TraceViewItem> m_queue = new MTQueue<TraceViewItem>();
                     bool m_paused;
                     readonly ManualResetEvent m_pauseEvent = new ManualResetEvent(true);
-                    public InteractiveListener() {
+                    public InteractiveListener(bool global) : base(global) {
-                        m_guiFinished = AsyncPool.InvokeNewThread(() => {
+                        m_guiFinished = AsyncPool.InvokeNewThread(GuiThread);
-                            GuiThread();
+                        m_workerFinished = AsyncPool.InvokeNewThread(QueueThread);
-                            return 0;
-                        });
                         m_guiStarted.Join();
                     }
                     void GuiThread() {
                         m_form = new TraceForm(); // will create SynchronizationContext
+                        m_form.PauseEvents += (s,a) => Pause();
+                        m_form.ResumeEvents += (s, a) => Resume();
                         m_syncGuiThread = SynchronizationContext.Current;
                         m_guiStarted.Resolve();
                         Application.Run();
                     }
                     void Terminate() {
+                        m_exitPending = true;
+                        Resume();
                         m_syncGuiThread.Post(x => Application.ExitThread(), null);
                     }
                         }
                         base.Dispose(disposing);
                     }
+                    protected override void WriteEntry(TraceContext context, EventText text, string channel) {
+                        var item = new TraceViewItem {
+                            Indent = text.indent,
+                            Message = text.content,
+                            Thread = context.ThreadId,
+                            Channel = channel,
+                            Timestamp = Environment.TickCount
+                        };
+                        Enqueue(item);
+                    }
                 }
             }

Implab.Diagnostics.Interactive/TraceForm.Designer.cs +12 0

                         this.eventsDataGrid = new System.Windows.Forms.DataGridView();
                         this.traceViewItemBindingSource = new System.Windows.Forms.BindingSource(this.components);
                         this.threadDataGridViewTextBoxColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+                        this.Channel = new System.Windows.Forms.DataGridViewTextBoxColumn();
                         this.messageDataGridViewTextBoxColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
                         ((System.ComponentModel.ISupportInitialize)(this.eventsDataGrid)).BeginInit();
                         ((System.ComponentModel.ISupportInitialize)(this.traceViewItemBindingSource)).BeginInit();
                         this.eventsDataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
                         this.eventsDataGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
                         this.threadDataGridViewTextBoxColumn,
+                        this.Channel,
                         this.messageDataGridViewTextBoxColumn});
                         this.eventsDataGrid.DataSource = this.traceViewItemBindingSource;
                         dataGridViewCellStyle3.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
                         this.threadDataGridViewTextBoxColumn.ReadOnly = true;
                         this.threadDataGridViewTextBoxColumn.Width = 5;
                         //
+                        // Channel
+                        //
+                        this.Channel.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.DisplayedCells;
+                        this.Channel.DataPropertyName = "Channel";
+                        this.Channel.HeaderText = "Channel";
+                        this.Channel.Name = "Channel";
+                        this.Channel.ReadOnly = true;
+                        this.Channel.Width = 79;
+                        //
                         // messageDataGridViewTextBoxColumn
                         //
                         this.messageDataGridViewTextBoxColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.Fill;
                     private System.Windows.Forms.DataGridView eventsDataGrid;
                     private System.Windows.Forms.BindingSource traceViewItemBindingSource;
                     private System.Windows.Forms.DataGridViewTextBoxColumn threadDataGridViewTextBoxColumn;
+                    private System.Windows.Forms.DataGridViewTextBoxColumn Channel;
                     private System.Windows.Forms.DataGridViewTextBoxColumn messageDataGridViewTextBoxColumn;
                 }

Implab.Diagnostics.Interactive/TraceForm.cs +7 -12

                     readonly Dictionary<int, Color> m_threadColors = new Dictionary<int,Color>();
                     readonly Random m_rand = new Random();
+                    public event EventHandler PauseEvents;
+                    public event EventHandler ResumeEvents;
                     public TraceForm() {
                         InitializeComponent();
                     }
                     protected override void OnFormClosing(FormClosingEventArgs e) {
                         }
                     }
-                    public void AddTraceEvent(int indent, int thread, string message) {
-                        traceViewItemBindingSource.Add(new TraceViewItem {
-                            Indent = indent,
-                            Thread = thread,
-                            Message = message,
-                            Timestamp = Environment.TickCount
-                        });
                     public void AddTraceEvent(TraceViewItem item) {
                         traceViewItemBindingSource.Add(item);
+                        eventsDataGrid.FirstDisplayedScrollingRowIndex = eventsDataGrid.RowCount - 1;
                     }
                     Color GetThreadColor(int thread) {
                     private void eventsDataGrid_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e) {
                         var data = (TraceViewItem)traceViewItemBindingSource[e.RowIndex];
-                        e.CellStyle.Padding = new Padding(data.Indent * 10,0,0,0);
+                        if (e.ColumnIndex == messageDataGridViewTextBoxColumn.Index)
+                            e.CellStyle.Padding = new Padding(data.Indent * 10,0,0,0);
                         e.CellStyle.ForeColor = GetThreadColor(data.Thread);
                     }
                 }

Implab.Diagnostics.Interactive/TraceForm.resx +3 0

               <resheader name="writer">
                 <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
               </resheader>
+              <metadata name="Channel.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+                <value>True</value>
+              </metadata>
               <metadata name="traceViewItemBindingSource.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
                 <value>17, 17</value>
               </metadata>

Implab.Diagnostics.Interactive/TraceViewItem.cs +1 0

                     public int Timestamp { get; set; }
                     public int Indent { get; set; }
                     public int Thread { get; set; }
+                    public string Channel { get; set; }
                     public string FormattedMessage {
                         get {

Implab/Diagnostics/ConsoleTraceListener.cs +4 -4

                     }
-                    public ConsoleTraceListener(bool local)
+                    public ConsoleTraceListener(bool global)
-                        : base(local) {
+                        : base(global) {
                     }
-                    protected override void WriteEntry(TraceContext context, EventText text) {
+                    protected override void WriteEntry(TraceContext context, EventText text, string channel) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < text.indent; i++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
+                        msg.AppendFormat("[{0}]:{1}: {2}", context.ThreadId, channel, text.content);
                         lock (_consoleLock) {
                             Console.ForegroundColor = (ConsoleColor)(context.ThreadId % 15 + 1);

Implab/Diagnostics/LogChannel.cs +51 0

@@ -4,23 +4,74 using System.Linq;
4	using System.Text;	4	using System.Text;
5		5
6	namespace Implab.Diagnostics {	6	namespace Implab.Diagnostics {
		7	/// <summary>
		8	/// Канал, через который публикуются события журнала.
		9	/// </summary>
		10	/// <typeparam name="TEvent">Тип событий в канале</typeparam>
		11	/// <remarks>
		12	/// Событиями журнала могут быть любые типы, например строки, в которых будет передаваться
		13	/// информация, или структуры с набором полей, описывающих важность, текст и другую информацию.
		14	/// </remarks>
7	public class LogChannel<TEvent> {	15	public class LogChannel<TEvent> {
8	static LogChannel<TEvent> _default = new LogChannel<TEvent>();	16	static LogChannel<TEvent> _default = new LogChannel<TEvent>();
9		17
		18	/// <summary>
		19	/// Канал по-умолчанию для событий типа <typeparam name="TEvent"/>.
		20	/// </summary>
10	public static LogChannel<TEvent> Default {	21	public static LogChannel<TEvent> Default {
11	get {	22	get {
12	return _default;	23	return _default;
13	}	24	}
14	}	25	}
15		26
		27	/// <summary>
		28	/// Событие появление новой записи в журнале, на это событие подписываются слушатели.
		29	/// </summary>
16	public event EventHandler<ValueEventArgs<TEvent>> Events;	30	public event EventHandler<ValueEventArgs<TEvent>> Events;
		31
		32	/// <summary>
		33	/// Имя канала, полезно для отображения в журнале
		34	/// </summary>
		35	public string Name {
		36	get;
		37	private set;
		38	}
17		39
		40	/// <summary>
		41	/// Создает журнал, имя типа событий назначается в качетве имени канала.
		42	/// </summary>
		43	public LogChannel()
		44	: this(null) {
		45	}
		46
		47	/// <summary>
		48	/// Содает канал с указанным именем.
		49	/// </summary>
		50	/// <param name="name">Имя канала.</param>
		51	public LogChannel(string name) {
		52	if (String.IsNullOrEmpty(name))
		53	name = typeof(TEvent).Name;
		54	Name = name;
		55	}
		56
		57	/// <summary>
		58	/// Отправляет запись журнала через канал подписчикам.
		59	/// </summary>
		60	/// <param name="data">Запись журнала.</param>
		61	/// <remarks>
		62	/// Контекст трассировки от которого рассылается сообщение определяется автоматически из текущего потока.
		63	/// </remarks>
18	public void LogEvent(TEvent data) {	64	public void LogEvent(TEvent data) {
19	var t = Events;	65	var t = Events;
20	if (t!= null)	66	if (t!= null)
21	t(TraceContext.Current,new ValueEventArgs<TEvent>(data));	67	t(TraceContext.Current,new ValueEventArgs<TEvent>(data));
22	}	68	}
23		69
		70	/// <summary>
		71	/// Отправляет запись журнала через канал подписчикам.
		72	/// </summary>
		73	/// <param name="data">Запись журнала.</param>
		74	/// <param name="context">Контекст трассировки от которого рассылается сообщение/</param>
24	public void LogEvent(TraceContext context,TEvent data) {	75	public void LogEvent(TraceContext context,TEvent data) {
25	var t = Events;	76	var t = Events;
26	if (t != null)	77	if (t != null)

Implab/Diagnostics/TextFileListener.cs +4 -3

                 public class TextFileListener: TextListenerBase {
                     readonly TextWriter m_textWriter;
-                    public TextFileListener(string fileName, bool local) : base(local) {
+                    public TextFileListener(string fileName, bool global)
+                        : base(global) {
                         m_textWriter = File.CreateText(fileName);
                         m_textWriter.WriteLine("LOG {0}", DateTime.Now);
                         Register(this);
                     }
-                    protected override void WriteEntry(TraceContext context, EventText text) {
+                    protected override void WriteEntry(TraceContext context, EventText text, string channel) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < text.indent; i++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
+                        msg.AppendFormat("[{0}]:{1}: {2}", context.ThreadId, channel, text.content);
                         lock (m_textWriter) {
                             if (!IsDisposed) {

Implab/Diagnostics/TextListenerBase.cs +5 -4

                     readonly LogicalOperation m_boundOperation;
                     readonly int m_baseIndent;
-                    protected TextListenerBase(bool local) {
+                    protected TextListenerBase(bool global) {
                         Register(this);
-                        if (local) {
+                        if (!global) {
                             m_boundOperation = TraceContext.Current.CurrentOperation;
                             m_baseIndent = Math.Max(0, m_boundOperation.Level - 1);
                         }
                             AssertNotDisposed();
                             var formatter = GetService<IEventTextFormatter<TEvent>>();
+                            var channelName = channel.Name;
                             EventHandler<ValueEventArgs<TEvent>> handler = (sender, args) => {
                                 TraceContext context = (TraceContext)sender;
                                 text.indent -= m_baseIndent;
                                 if (IsRelated(context.CurrentOperation))
-                                    WriteEntry(context, text);
+                                    WriteEntry(context, text, channelName);
                             };
                             if (m_subscriptions.ContainsKey(channel))
                     /// </remarks>
                     /// <param name="context">Контекст трассировки.</param>
                     /// <param name="text">Текст сообщения.</param>
-                    protected abstract void WriteEntry(TraceContext context, EventText text);
+                    protected abstract void WriteEntry(TraceContext context, EventText text, string channel);
                     public EventText Format(TraceContext context, object data) {
                         return new EventText {

Implab/Diagnostics/TraceContext.cs +47 -8

                     /// </summary>
                     public static TraceContext Current {
                         get {
-                            if (_current == null)
+                            if (_current == null) {
                                 _current = new TraceContext();
+                                _current.LogEvent(TraceEventType.Created,"[{0}]", _current.ThreadId);
+                            }
                             return _current;
                         }
                     }
-                    TraceContext(TraceContext context) {
+                    TraceContext(TraceContext context)
+                        : this(context, false) {
+                    }
+                    TraceContext(TraceContext context, bool attach) {
                         if (context == null)
                             throw new ArgumentNullException("context");
                         m_currentOperation = context.CurrentOperation;
-                        m_bound = context.CurrentOperation;
+                        m_bound = attach ? context.BoundOperation : context.CurrentOperation;
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
                     }
                     /// контексте ранее начатые логические операции не могут быть завершены.
                     /// </para>
                     /// <para>
-                    /// Если передача состояния состоялась, то вызывается событие трассировки <see cref="TraceEventType.Transfer"/>.
+                    /// Если передача состояния состоялась, то вызывается событие трассировки <see cref="TraceEventType.Fork"/>.
                     /// </para>
                     /// </remarks>
-                    public static void Transfer(TraceContext from) {
+                    public static void Fork(TraceContext from) {
                         if (_current == from)
                             return;
                         if (from != null) {
                             var context = new TraceContext(from);
-                            context.LogEvent(TraceEventType.Transfer, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);
+                            context.LogEvent(TraceEventType.Fork, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);
                             _current = context;
                         } else {
                             _current = new TraceContext();
                     }
                     /// <summary>
-                    /// Создает постоянную копию текущего контекста, данную копию можно хранить и использовать для передачи через <see cref="Transfer(TraceContext)"/>
+                    /// Задает текущему потоку указанный контекст, текущей поток может заканчивать ранее начатые
+                    /// логические операции в указанном контексте.
+                    /// </summary>
+                    /// <param name="source"></param>
+                    public static void Attach(TraceContext source) {
+                        if (_current == source)
+                            return;
+                        if (source != null) {
+                            var context = new TraceContext(source, true);
+                            context.LogEvent(TraceEventType.Attach, "[{0}]-->[{1}]", source.ThreadId, context.ThreadId);
+                            _current = context;
+                        } else {
+                            _current = new TraceContext();
+                        }
+                    }
+                    /// <summary>
+                    /// Отсоединяет текущий контекст трассировки от потока, для дальнейшей его передачи другому потоку
+                    /// <see cref="Attach(TraceContext)"/>.
+                    /// </summary>
+                    /// <returns>Контекст трассировки потока</returns>
+                    /// <remarks>
+                    /// После отсоединения контекста трассировки от потока, при первом обращении к трассировке в этом
+                    /// потоке будет создан новый контекст.
+                    /// </remarks>
+                    public static TraceContext Detach() {
+                        var context = Current;
+                        context.LogEvent(TraceEventType.Detach, null);
+                        _current = null;
+                        return context;
+                    }
+                    /// <summary>
+                    /// Создает постоянную копию текущего контекста, данную копию можно хранить и использовать для передачи через <see cref="Fork(TraceContext)"/>
                     /// </summary>
                     /// <returns>Копия текущего контекста трассировки.</returns>
                     public static TraceContext Snapshot() {
                         if (action == null)
                             throw new ArgumentNullException("action");
                         var old = _current;
-                        Transfer(this);
+                        Fork(this);
                         try {
                             action();
                         } finally {

Implab/Diagnostics/TraceEventType.cs +4 -1

                     Error,
                     OperationStarted,
                     OperationCompleted,
-                    Transfer
+                    Fork,
+                    Attach,
+                    Detach,
+                    Created
                 }
             }

Implab/Disposable.cs +19 -3

-            using System;
+            using Implab.Diagnostics;
+            using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Web;
             namespace Implab {
+                /// <summary>
+                /// Объект, поддерживающий освобождение ресурсов.
+                /// </summary>
                 public class Disposable : IDisposable {
                     bool m_disposed;
                         if (m_disposed)
                             throw new ObjectDisposedException(this.ToString());
                     }
+                    /// <summary>
+                    /// Переводит объект в состояние <c>Disposed</c> и вызывает событие <see cref="Disposed"/>
+                    /// </summary>
+                    /// <param name="disposing">Признак того, что нужно освободить ресурсы, иначе данный метод
+                    /// вызван сборщиком мусора и нужно освобождать ТОЛЬКО неуправляемые ресурсы ТОЛЬКО этого
+                    /// объекта.</param>
+                    /// <remarks>
+                    /// Данный метод осуществляет проверку того, что объект уже был освобожден, чтобы не вызывать
+                    /// событие <see cref="Disposed"/>. Не поддерживает многопоточность.
+                    /// </remarks>
                     protected virtual void Dispose(bool disposing) {
                         if (disposing && !m_disposed) {
                             m_disposed = true;
                         GC.SuppressFinalize(this);
                     }
+                    /// <summary>
+                    /// Записывает сообщение об утечке объекта.
+                    /// </summary>
                     protected virtual void ReportObjectLeaks() {
-                        Trace.TraceWarning("The object is marked as disposable but isn't disposed properly: {0}", this);
+                        TraceLog.TraceWarning("The object is marked as disposable but isn't disposed properly: {0}", this);
                     }
                     ~Disposable() {

Implab/Parallels/ArrayTraits.cs +2 -2

                         }
                         protected override void Worker() {
-                            TraceContext.Transfer(m_traceContext);
+                            TraceContext.Fork(m_traceContext);
                             base.Worker();
                         }
                         }
                         protected override void Worker() {
-                            TraceContext.Transfer(m_traceContext);
+                            TraceContext.Fork(m_traceContext);
                             base.Worker();
                         }

Implab/Parallels/AsyncPool.cs +23 -2

                         var caller = TraceContext.Snapshot();
             			ThreadPool.QueueUserWorkItem(param => {
-                            TraceContext.Transfer(caller);
+                            TraceContext.Fork(caller);
             				try {
             					p.Resolve(func());
             				} catch(Exception e) {
                         var caller = TraceContext.Snapshot();
                         var worker = new Thread(() => {
-                            TraceContext.Transfer(caller);
+                            TraceContext.Fork(caller);
                             try {
                                 p.Resolve(func());
                             } catch (Exception e) {
                         return p;
                     }
+                    public static IPromiseBase InvokeNewThread(Action func) {
+                        var p = new Promise<object>();
+                        var caller = TraceContext.Snapshot();
+                        var worker = new Thread(() => {
+                            TraceContext.Fork(caller);
+                            try {
+                                func();
+                                p.Resolve();
+                            } catch (Exception e) {
+                                p.Reject(e);
+                            }
+                        });
+                        worker.IsBackground = true;
+                        worker.Start();
+                        return p;
+                    }
             	}
             }

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