private void WriteToTraceListener()
{
while (true)
{
var messages = GetAllMessagesFromQueue();
foreach (var message in messages)
{
foreach (var traceListener in traceListeners)
{
var messageAsXml = ComposeXmlMessage(message, traceListener.GetTraceOptions());
lock (traceListener)
{
try
{
traceListener.WriteAsync(messageAsXml);
}
catch (Exception ex)
{
StatusReporter.Report(string.Format(Resources.ErrTraceListenerThrowsExceptionOnWrite, ex.ToString()), Status.ERROR);
}
}
}
}
}
}
/// <summary>
/// Enables the Trace manager to register for Debugger break events;
/// </summary>
/// <param name="unsubscribeOnDebugSessionEnd"></param>
void SubscribeForDebuggerEvents()
{
if (subscribedForDebuggerBreak)
{
StatusReporter.Report(Resources.MsgAlreadySubscribedForDbgBreak, Status.INFO);
return;
}
if (!dteInitialized)
{
InitializeDTE();
}
//Cache the debuggerEvents object so that it is not disposed by the shell.
debuggerEvents = dte.Events.DebuggerEvents;
if (debuggerEvents == null)
{
throw new NullReferenceException(Resources.MsgDebuggerEventsObjNull);
}
debuggerEvents.OnEnterBreakMode += new EnvDTE._dispDebuggerEvents_OnEnterBreakModeEventHandler(DebuggerEvents_OnEnterBreakMode);
debuggerEvents.OnEnterDesignMode += new _dispDebuggerEvents_OnEnterDesignModeEventHandler(debuggerEvents_OnEnterDesignMode);
StatusReporter.Report(Resources.MsgDbgBreakEventSubscribeSuccess, Status.INFO);
subscribedForDebuggerBreak = true;
}
/// <summary>
/// Initializes a new instance of Trace Manager
/// </summary>
private TraceManager()
{
symbols = new List <string>();
this.traceListeners = new List <ITraceMessageListener>();
InitializeDTE();
StatusReporter.Report(Resources.MsgTraceInitialized, Status.INFO);
}
internal IEnumerable <string> GetSymbols()
{
if (symbols != null && symbols.Any())
{
StatusReporter.Report(Resources.MsgSymbolsReturnedSuccesfully, Status.INFO);
return(symbols);
}
else
{
throw new InvalidOperationException(Resources.ErrorSymbolSourceIsNullOrEmpty);
}
}
public void AddSymbol(string symbolName)
{
if (!canUpdateSymbolList)
{
StatusReporter.Report(Resources.ErrCannotUpdateSymbolList, Status.ERROR);
throw new InvalidOperationException(Resources.ErrCannotUpdateSymbolList);
}
lock (symbols)
{
this.symbols.Add(symbolName);
}
}
private void InitializeTraceMessagePump()
{
if (traceMessagePumpInitialized)
{
StatusReporter.Report(Resources.MsgMessagePumpAlreadyInitialized, Status.INFO);
return;
}
messages = new Queue <TraceMessageSourceEntry>();
traceMessgePumpThread = new System.Threading.Thread(new ThreadStart(WriteToTraceListener));
traceMessgePumpThread.Name = "Ichnos Trace Listener";
traceMessgePumpThread.Start();
}
public void Disable()
{
debuggerEvents.OnEnterBreakMode -= new _dispDebuggerEvents_OnEnterBreakModeEventHandler(DebuggerEvents_OnEnterBreakMode);
StatusReporter.Report(Resources.MsgBreakEventHandlerUnsubscribed, Status.INFO);
}
void DebuggerEvents_OnEnterBreakMode(EnvDTE.dbgEventReason Reason, ref EnvDTE.dbgExecutionAction ExecutionAction)
{
try
{
traceSessionInProgress = true;
Debugger debugger;
lock (dte)
{
//Don't lock too much, just what is required.
debugger = dte.Debugger;
}
if (Reason == dbgEventReason.dbgEventReasonBreakpoint)
{
string[] symbols;
lock (this.symbols)
{
//Clone the list to be used locally.
symbols = new string[this.symbols.Count];
this.symbols.CopyTo(symbols);
}
foreach (var symbol in symbols)
{
if (!string.IsNullOrEmpty(symbol))
{
try
{
var expression = debugger.GetExpression(symbol);
if (expression.IsValidValue)
{
var breakpoint = debugger.BreakpointLastHit;
var stackFrame = debugger.CurrentStackFrame;
var traceMessageSource = new TraceMessageSourceEntry()
{
Expression = expression, Breakpoint = breakpoint, StackFrame = stackFrame
};
lock (messages)
{
messages.Enqueue(traceMessageSource);
}
}
else
{
string breakpointContext;
var bp = dte.Debugger.BreakpointLastHit;
breakpointContext = string.Format(Resources.MsgBreakpointContextFormat, expression.Name, bp.FunctionName, bp.FileLine);
StatusReporter.Report(string.Format(Resources.ErrTraceSymbolInvalid, breakpointContext), Status.WARNING);
}
}
catch (Exception ex)
{
StatusReporter.Report(string.Format(Resources.ErrorEvaulatingSymbol, symbol + ex.ToString()), Status.WARNING);
}
}
}
}
}
finally
{
//This step makes sure that the execution continues after tracing this value;
ExecutionAction = dbgExecutionAction.dbgExecutionActionGo;
}
}
