implab/ImplabNet Commit - r52:edf0bc558596

improved trace system

cin -

r52:edf0bc558596 default

parent child

Context file:

r52:edf0bc558596

Collapse all files

Implab/Diagnostics/TraceContext.cs +28 -1

              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();
                                  _current.LogEvent(TraceEventType.Created,"[{0}]", _current.ThreadId);
                              }
                              return _current;
                          }
                      }
                      TraceContext(TraceContext context)
                          : this(context, false) {
                      }
                      TraceContext(TraceContext context, bool attach) {
                          if (context == null)
                              throw new ArgumentNullException("context");
                          m_currentOperation = context.CurrentOperation;
                          m_bound = attach ? context.BoundOperation : 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.Fork"/>.
                      /// </para>
                      /// </remarks>
                      public static void Fork(TraceContext from) {
                          if (_current == from)
                              return;
                          if (from != null) {
                              var context = new TraceContext(from);
                              context.LogEvent(TraceEventType.Fork, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);
                              _current = context;
                          } else {
                              _current = new TraceContext();
                          }
                      }
                      /// <summary>
                      /// Задает текущему потоку указанный контекст, текущей поток может заканчивать ранее начатые
                      /// логические операции в указанном контексте.
                      /// </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() {
-                         return _current == null ? new TraceContext() : new TraceContext(_current);
+                         return _current == null ? new TraceContext() : new TraceContext(_current,false);
                      }
                      /// <summary>
                      /// Выполняет переданное действие в указанном контексте трассировки, по окончании восстанавливает предыдущий контекст трассировки потока.
                      /// </summary>
                      /// <param name="action"></param>
                      public void Invoke(Action action) {
                          if (action == null)
                              throw new ArgumentNullException("action");
                          var old = _current;
                          Fork(this);
                          try {
                              action();
                          } finally {
+                             if(_current != null)
                              _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>
+                     /// <returns>Контекст трассировки, который можно присоединить к другому потоку.</returns>
+                     public TraceContext DetachLogicalOperation() {
+                         if (m_bound == m_currentOperation) {
+                             return new TraceContext();
+                         } else {
+                             var detached = new TraceContext(this, true);
+                             m_currentOperation = m_currentOperation.Parent;
+                             return detached;
+                         }
+                     }
+                     public void BindLogicalOperationToPromise(IPromiseBase promise) {
+                         Safe.ArgumentNotNull(promise, "promise");
+                         var ctx = DetachLogicalOperation();
+                         promise.Finally(() => {
+                             var old = _current;
+                             TraceContext.Attach(ctx);
+                             TraceContext.Current.EndLogicalOperation();
+                             _current = old;
+                         });
+                     }
+                     /// <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 +3 0

              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() {
+                         if (EventType == TraceEventType.Information)
+                             return Message;
+                         else
                          return String.Format("{0}: {1}", EventType, Message);
                      }
                      public static TraceEvent Create(TraceEventType type, string format, params object[] args) {
                          return new TraceEvent(type, format == null ? String.Empty : String.Format(format, args));
                      }
                  }
              }

Implab/Diagnostics/TraceLog.cs +5 0

              using System;
              using System.Collections.Generic;
              using System.Diagnostics;
              using System.Linq;
              using System.Text;
              using System.Threading.Tasks;
              namespace Implab.Diagnostics {
                  /// <summary>
                  /// Класс для публикации событий выполнения программы, события публикуются через <see cref="LogChannel{TraceEvent}"/>.
                  /// Журнал трассировки отражает логический ход выполнения программы и существует всегда, поскольку тесно связан с
                  /// контекстом трассировки.
                  /// </summary>
                  public static class TraceLog {
                      [Conditional("TRACE")]
                      public static void StartLogicalOperation() {
                          TraceContext.Current.StartLogicalOperation();
                      }
                      [Conditional("TRACE")]
                      public static void StartLogicalOperation(string name) {
                          TraceContext.Current.StartLogicalOperation(name);
                      }
                      [Conditional("TRACE")]
                      public static void EndLogicalOperation() {
                          TraceContext.Current.EndLogicalOperation();
                      }
                      [Conditional("TRACE")]
+                     public static void BindLogicalOperationToPromise(IPromiseBase promise) {
+                         TraceContext.Current.BindLogicalOperationToPromise(promise);
+                     }
+                     [Conditional("TRACE")]
                      public static void TraceInformation(string format, params object[] arguments) {
                          LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Information, format, arguments));
                      }
                      [Conditional("TRACE")]
                      public static void TraceWarning(string format, params object[] arguments) {
                          LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Warning, format, arguments));
                      }
                      [Conditional("TRACE")]
                      public static void TraceError(string format, params object[] arguments) {
                          LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Error, format, arguments));
                      }
                      [Conditional("TRACE")]
                      public static void TraceError(Exception err) {
                          TraceError("{0}", err);
                      }
                  }
              }

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