Roughly handles WPP events to avoid RegisteredTraceEventParser assertions

Author: wwh1004

src/TraceEvent/RegisteredTraceEventParser.cs

@@ -621,6 +621,12 @@ internal override DynamicTraceEventData TryLookup(TraceEvent unknownEvent)
         /// </summary>
         internal static DynamicTraceEventData TryLookupWorker(TraceEvent unknownEvent, Dictionary<MapKey, IDictionary<long, string>> mapTable = null)
         {
+            // We are not able to handle WPP events in this parser.
+            if (unknownEvent.lookupAsWPP)
+            {
+                return null;
+            }
+
             // Is this a TraceLogging style 
             DynamicTraceEventData ret = null;
 
@@ -1192,7 +1198,7 @@ protected unsafe ExternalTraceEventParser(TraceEventSource source, bool dontRegi
                         parsedTemplate = TryLookup(unknown);
                         if (parsedTemplate == null)
                         {
-                            m_state.m_templates.Add(unknown.Clone(), null);         // add an entry to remember that we tried and failed.  
+                            m_state.m_templates.Add(unknown.CloneToTemplate(), null);         // add an entry to remember that we tried and failed.  
                         }
                     }
                     if (parsedTemplate == null)
@@ -1369,7 +1375,6 @@ internal class TraceEventComparer : IEqualityComparer<TraceEvent>
         {
             public bool Equals(TraceEvent x, TraceEvent y)
             {
-                Debug.Assert(!(x.lookupAsWPP && x.lookupAsClassic));
                 if (x.lookupAsClassic != y.lookupAsClassic)
                 {
                     return false;
@@ -1380,15 +1385,15 @@ public bool Equals(TraceEvent x, TraceEvent y)
                     return false;
                 }
 
-                if (x.lookupAsClassic)
+                if (x.lookupAsWPP)
                 {
                     Debug.Assert(x.taskGuid != Guid.Empty && y.taskGuid != Guid.Empty);
-                    return (x.taskGuid == y.taskGuid) && (x.Opcode == y.Opcode);
+                    return (x.taskGuid == y.taskGuid) && (x.ID == y.ID);
                 }
-                else if (x.lookupAsWPP)
+                else if (x.lookupAsClassic)
                 {
                     Debug.Assert(x.taskGuid != Guid.Empty && y.taskGuid != Guid.Empty);
-                    return (x.taskGuid == y.taskGuid) && (x.ID == y.ID);
+                    return (x.taskGuid == y.taskGuid) && (x.Opcode == y.Opcode);
                 }
                 else
                 {

src/TraceEvent/TraceEvent.cs

@@ -977,6 +977,14 @@ public bool IsClassicProvider
             // [SecuritySafeCritical]
             get { return (eventRecord->EventHeader.Flags & TraceEventNativeMethods.EVENT_HEADER_FLAG_CLASSIC_HEADER) != 0; }
         }
+        /// <summary>
+        /// Returns true if this event is from the TraceMessage function (typically indicates from a WPP provider)
+        /// </summary>
+        public bool IsTraceMessage
+        {
+            // [SecuritySafeCritical]
+            get { return (eventRecord->EventHeader.Flags & TraceEventNativeMethods.EVENT_HEADER_FLAG_TRACE_MESSAGE) != 0; }
+        }
 
         /// <summary>
         /// The ID of the container that emitted the event, if available.
@@ -2015,9 +2023,18 @@ protected internal virtual void SetState(object state) { }
 
         protected internal TraceEvent CloneToTemplate()
         {
-            TraceEvent ret = Clone();
+            TraceEvent ret;
+            var record = eventRecord;
+            try
+            {
+                eventRecord = null;
+                ret = Clone();
+            }
+            finally
+            {
+                eventRecord = record;
+            }
             ret.traceEventSource = null;
-            ret.eventRecord = null;
             ret.Target = null;
             return ret;
         }
@@ -3663,6 +3680,7 @@ internal TraceEvent Lookup(TraceEventNativeMethods.EVENT_RECORD* eventRecord)
 
 #if DEBUG                   // ASSERT we found the event using the mechanism we expected to use.
                         Debug.Assert(((eventRecord->EventHeader.Flags & TraceEventNativeMethods.EVENT_HEADER_FLAG_CLASSIC_HEADER) != 0) == curTemplate.lookupAsClassic);
+                        Debug.Assert(((eventRecord->EventHeader.Flags & TraceEventNativeMethods.EVENT_HEADER_FLAG_TRACE_MESSAGE) != 0) == curTemplate.lookupAsWPP);
                         if (curTemplate.lookupAsClassic)
                         {
                             Debug.Assert(curTemplate.taskGuid == eventRecord->EventHeader.ProviderId);
@@ -3710,6 +3728,7 @@ internal TraceEvent Lookup(TraceEventNativeMethods.EVENT_RECORD* eventRecord)
             unhandledEventTemplate.userData = eventRecord->UserData;
             unhandledEventTemplate.eventIndex = currentID;
             unhandledEventTemplate.lookupAsClassic = unhandledEventTemplate.IsClassicProvider;
+            unhandledEventTemplate.lookupAsWPP = unhandledEventTemplate.IsTraceMessage;
             if ((((int)currentID) & 0xFFFF) == 0)       // Every 64K events allow Thread.Interrupt.  
             {
                 System.Threading.Thread.Sleep(0);

src/TraceEvent/TraceEventNativeMethods.cs

@@ -399,6 +399,7 @@ internal static extern int TraceQueryInformation(
         */
 
         internal const ushort EVENT_HEADER_FLAG_STRING_ONLY = 0x0004;
+        internal const ushort EVENT_HEADER_FLAG_TRACE_MESSAGE = 0x0008;
         internal const ushort EVENT_HEADER_FLAG_NO_CPUTIME = 0x0010;
         internal const ushort EVENT_HEADER_FLAG_32_BIT_HEADER = 0x0020;
         internal const ushort EVENT_HEADER_FLAG_64_BIT_HEADER = 0x0040;