public void Add(ITraceEvent traceEvent)
{
var message = new StringBuilder();
if (HttpContext.Current != null)
{
message.Append("During HTTP request to: ");
message.Append(HttpContext.Current.Request.Url);
message.AppendLine();
}
message.Append("Instance ");
message.Append(traceEvent.Source.TraceId);
message.Append(" of type ");
message.Append(traceEvent.Source.GetType());
message.Append(" reported: ");
message.Append(traceEvent.Message);
message.AppendLine();
if (traceEvent.IsError)
{
log.Error(message.ToString());
}
else
{
log.Debug(message.ToString());
}
}
public void OnEvent(ITraceEvent Event, ITraceRelogger Relogger)
{
IntPtr recordPtr;
Event.GetEventRecord(out recordPtr);
EVENT_RECORD record = (EVENT_RECORD)Marshal.PtrToStructure(recordPtr, typeof(EVENT_RECORD));
if (IsStackWalkRecord(ref record))
{
// path the timestamp in the stack walk record.
Marshal.WriteInt64(record.UserData, _currentTimeStamp);
_currentTimeStamp += _ticksPerStack;
if (record.UserDataLength == EmptyStackWalkSize)
{
// this is an empty stack walk, which means that the CPU is actually idle.
// We inject these when writing the log, and then remove them when doing
// the rewrite. This lets us keep the correct timing information but removing
// them gets us correct CPU information in the graph.
return;
}
}
var prevTimeStamp = record.EventHeader.TimeStamp;
var newTimeStamp = _currentTimeStamp;
Event.SetTimeStamp(ref newTimeStamp);
if (IsStackWalkRecord(ref record))
{
}
Relogger.Inject(Event);
}
public void Add(ITraceEvent traceEvent)
{
var message = new StringBuilder();
if (HttpContext.Current != null)
{
message.Append("During HTTP request to: ");
message.Append(HttpContext.Current.Request.Url);
message.AppendLine();
}
message.Append("Instance ");
message.Append(traceEvent.Source.TraceId);
message.Append(" of type ");
message.Append(traceEvent.Source.GetType());
message.Append(" reported: ");
message.Append(traceEvent.Message);
message.AppendLine();
if (traceEvent.IsError)
{
log.Error(message.ToString());
}
else
{
log.Debug(message.ToString());
}
}
public static void MapTo(this ITraceEvent traceEvent, TraceEvent mapToEvent)
{
foreach (var memberGetter in MemberGetters)
{
var value = memberGetter.Value.Invoke(traceEvent);
mapToEvent.SetPropertyValue(memberGetter.Key, value);
}
}
private unsafe void SetPayload(ITraceEvent newEvent, IList <object> payloadArgs)
{
// Where we are writing the serialized data in m_scratchBuffer
int curBlobPtr = 0;
// Need to serialize the objects according to ETW serialization conventions.
foreach (var payloadArg in payloadArgs)
{
var argType = payloadArg.GetType();
if (argType == typeof(string))
{
var asString = (string)payloadArg;
var bytesNeeded = (asString.Length + 1) * 2;
var newCurBlobPtr = curBlobPtr + bytesNeeded;
EnsureSratchBufferSpace(newCurBlobPtr);
// Copy the string.
char *toPtr = (char *)(&m_scratchBuffer[curBlobPtr]);
fixed(char *fromPtr = asString)
{
for (int i = 0; i < asString.Length; i++)
{
toPtr[i] = fromPtr[i];
}
toPtr[asString.Length] = '\0';
}
curBlobPtr += newCurBlobPtr;
}
else if (argType == typeof(int))
{
EnsureSratchBufferSpace(curBlobPtr + 4);
*((int *)&m_scratchBuffer[curBlobPtr]) = (int)payloadArg;
curBlobPtr += 4;
}
else if (argType == typeof(long))
{
EnsureSratchBufferSpace(curBlobPtr + 8);
*((long *)&m_scratchBuffer[curBlobPtr]) = (long)payloadArg;
curBlobPtr += 8;
}
else if (argType == typeof(double))
{
EnsureSratchBufferSpace(curBlobPtr + 8);
*((double *)&m_scratchBuffer[curBlobPtr]) = (double)payloadArg;
curBlobPtr += 8;
}
else
{
throw new NotImplementedException();
}
}
newEvent.SetPayload(ref *m_scratchBuffer, (uint)curBlobPtr);
}
public void OnBeginProcessTrace(ITraceEvent HeaderEvent, ITraceRelogger Relogger)
{
IntPtr recordPtr;
HeaderEvent.GetEventRecord(out recordPtr);
EVENT_RECORD record = (EVENT_RECORD)Marshal.PtrToStructure(recordPtr, typeof(EVENT_RECORD));
EventTrace_Header props = (EventTrace_Header)Marshal.PtrToStructure(record.UserData, typeof(EventTrace_Header));
var ticksPerMs = props.PerfFreq / 1000;// PerfFreq is frequence in # of ticks per second (same as Stopwatch.Frequency)
var msPerStack = _executionTime.TotalMilliseconds / _stackWalkCount;
_ticksPerStack = (long)(ticksPerMs * (ulong)msPerStack);
}
public void Update_traceEvent_calls(string when)
{
using (var application = Platform.Win.NewApplication <ReactiveLoggerModule>()){
application.AddModule <TestReactiveLoggerModule>();
application.Title = nameof(Update_traceEvent_calls);
var objectSpace = application.CreateObjectSpace();
if (when == "DifferentLastEvent")
{
objectSpace.CreateObject <TraceEvent>();
objectSpace.CommitChanges();
}
else if (when == "SameLastEvent")
{
var traceEvent = objectSpace.CreateObject <TraceEvent>();
traceEvent.Source = "source";
traceEvent.Location = "Location";
traceEvent.Method = "Method";
traceEvent.Action = "Action";
objectSpace.CommitChanges();
}
var message1 = new TraceEventMessage()
{
Source = "source", Location = "Location", Method = "Method", Action = "Action"
};
var message2 = new TraceEventMessage()
{
Source = "source", Location = "Location", Method = "Method", Action = "Action2"
};
var messages = new ITraceEvent[] { message1, message1, message2 };
var save = objectSpace.SaveTraceEvent(messages).SubscribeReplay();
var testObserver = save.Test();
testObserver.ItemCount.ShouldBe(2);
if (when != "SameLastEvent")
{
testObserver.Items[0].Called.ShouldBe(2);
testObserver.Items[1].Called.ShouldBe(1);
}
else
{
testObserver.Items[0].Called.ShouldBe(3);
testObserver.Items[1].Called.ShouldBe(1);
}
}
}
public void OnEvent(ITraceEvent eventData, CTraceRelogger relogger)
{
var rawData = (TraceEventNativeMethods.EVENT_RECORD *)eventData.GetEventRecord();
var source = m_source;
if (source.stopProcessing)
{
return;
}
// is this the very first event? if so this could be the header event (for real time ETW)
if (m_source._syncTimeQPC == 0)
{
Initialize(rawData);
}
Debug.Assert(rawData->EventHeader.HeaderType == 0); // if non-zero probably old-style ETW header
// Give it an event ID if it does not have one.
source.m_traceLoggingEventId.TestForTraceLoggingEventAndFixupIfNeeded(rawData);
// Lookup the event;
TraceEvent anEvent = source.Lookup(rawData);
source.m_curITraceEvent = eventData;
source.m_curTraceEventRecord = anEvent.eventRecord;
// Keep in mind that for UnhandledTraceEvent 'PrepForCallback' has NOT been called, which means the
// opcode, guid and eventIds are not correct at this point. The ToString() routine WILL call
// this so if that is in your debug window, it will have this side effect (which is good and bad)
// Looking at rawData will give you the truth however.
anEvent.DebugValidate();
if (anEvent.NeedsFixup)
{
anEvent.FixupData();
}
source.Dispatch(anEvent);
// Release the COM object aggressively Otherwise you build up quite a few of these before
// the GC kicks in and cleans them all up.
Marshal.FinalReleaseComObject(source.m_curITraceEvent);
source.m_curITraceEvent = null;
}
public void OnBeginProcessTrace(ITraceEvent headerEvent, CTraceRelogger relogger)
{
var rawData = (TraceEventNativeMethods.EVENT_RECORD *)headerEvent.GetEventRecord();
Initialize(rawData);
}
public static void TraceEventMessage(this TraceSource traceSource, ITraceEvent traceEvent)
{
traceSource.TraceEvent(TraceEventType.Information, traceSource.GetHashCode(), $"{traceEvent.Location}.{traceEvent.Method}({traceEvent.Line}): {traceEvent.Action}({traceEvent.Value})");
}
public static string TraceKey(this ITraceEvent _)
{
return($"{_.Location}{_.Action}{_.Value}{_.Source}{_.Method}{_.Value}");
}
