Support IncompleteAsyncMethod (at least a bit).

.NET Core added an event that helps diagnose some kinds of async deadlock
(where code that should have triggered a task completion simply drops the
task that should have been signaled).     See release notes for more.

TraceEvent synthesizes a Version number to determine if one EventSource
manifest is 'better' than another.   Change it so that if you add a new event
the version goes a a lot, which allows you to also delete some entries and still
have a better version (see comments for more).

Author: Vance Morrison

src/Directory.Build.props

@@ -22,8 +22,8 @@
 
   <PropertyGroup>
     <!-- These are the versions of the things we are CREATING in this repository -->
-    <PerfViewVersion>2.0.27</PerfViewVersion>
-    <TraceEventVersion>2.0.27</TraceEventVersion>
+    <PerfViewVersion>2.0.28</PerfViewVersion>
+    <TraceEventVersion>2.0.28</TraceEventVersion>
   </PropertyGroup>
 
   <!-- versions of dependencies that more than one project use -->

src/PerfView/SupportFiles/UsersGuide.htm

@@ -8314,18 +8314,49 @@ <h2>
         </ul>
     </li>
     -->
+        <li>
+            Version 2.0.28 10/2/18
+            <ul>
+                <li>
+                    Fixed parsing of Task Parallel library parsing to include the .NET Core 2.1 event
+                    System.Threading.Tasks.TplEventSource/IncompleteAsyncMethod used to find 'orphaned' Async operations.  
+                    Also added this event  to the default collection for TPL, so that it is always 'just here'.
+
+                    Basically this is a new feature of the .NET Core task library that notices when tasks are created,
+                    but then collected without ever being completed one way or the other.   This can happen if the
+                    TaskCompletionSource dies before it calls 'Complete' on the task.  
+
+                    The string in the event is the name of the method where the orphaned machine (Task) will return
+                    when it continues.   The code that was supposed to trigger the 'await' to complete is at fault.  
+                    
+                    This feature needs to be friendlier but it is a big step from knowing nothing.  
+                </li>
+                <li> modified the TraceEvent library's concept of what the 'version of the manifest is to' include
+                a term that is 100 * the largest event ID.   Thus if you add a new event (at the end), you can 
+                remove (clean up) a few dozen unused events and still be considered 'better'.   Note that this should
+                be used with care, as it implys that the deleted events are not EVER useful (even for old code that
+                still emits them), because TraceEvent will not parse them going forward (The TPL EventSource did just
+                this which is why it came up here.)
+                </li>
+            </ul>
+        </li>
         <li>
             Version 2.0.27 9/25/18
             <ul>
-                <li> Fixed 'PerfView Listen EVENTSOURCE' so that it works without the * prefix for EventSources. 
+                <li>
+                    Fixed 'PerfView Listen EVENTSOURCE' so that it works without the * prefix for EventSources.
                 </li>
                 <li>Fixed missing descriptions for user commands</li>
-                <li>Added support for the /SessionName=XXXX parameter which renames both the user and kernel
-                    session names that perfView uses (which allow you to have two PerfView's running or run 
-                    with other tools that use the kernel provider)  </li>
+                <li>
+                    Added support for the /SessionName=XXXX parameter which renames both the user and kernel
+                    session names that perfView uses (which allow you to have two PerfView's running or run
+                    with other tools that use the kernel provider)
+                </li>
                 <li>Use stack compression by default</li>
-                <li>Stop the kernel and user mode session concurrently.  This helps when the disks are very 
-                slow (VMs), to keep the two sessions overlapping maximally</li>
+                <li>
+                    Stop the kernel and user mode session concurrently.  This helps when the disks are very
+                    slow (VMs), to keep the two sessions overlapping maximally
+                </li>
             </ul>
         </li>
         <li>

src/TraceEvent/DynamicTraceEventParser.cs

@@ -1972,8 +1972,12 @@ public void WriteToFile(string filePath)
         /// <summary>
         /// The version is defined as the sum of all the version numbers of event version numbers + the number of events defined. 
         /// This has the property that if you follow correct versioning protocol (all versions for a linear sequence where a new  
-        /// versions is only modifies is predecessor by adding new events or INCREASEING the version numbers of existing events) 
+        /// versions is only modifies is predecessor by adding new events or INCREASING the version numbers of existing events) 
         /// then the version number defined below will always strictly increase.   
+        ///
+        /// It turns out that .NET Core removed some events from the TplEtwProvider.   To allow removal of truly old events
+        /// we also add 100* the largest event ID defined to the version number.  That way if you add new events, even if you
+        /// removes some (less than 100) it will consider your 'better'.   
         /// </summary>
         public int Version
         {
@@ -1984,25 +1988,26 @@ public int Version
                     try
                     {
                         var verReader = ManifestReader;
-                        while (
-                            verReader.Read())
+                        var maxEventId = 0;
+                        while (verReader.Read())
                         {
                             if (verReader.NodeType != XmlNodeType.Element)
-                            {
                                 continue;
-                            }
 
                             if (verReader.Name == "event")
                             {
                                 version++;
                                 string ver = verReader.GetAttribute("version");
-                                int intVer;
-                                if (ver != null && int.TryParse(ver, out intVer))
-                                {
+                                if (ver != null && int.TryParse(ver, out int intVer))
                                     version += intVer;
-                                }
+
+                                string id = verReader.GetAttribute("value");
+                                if (id != null && int.TryParse(id, out int intId) && intId > maxEventId)
+                                    maxEventId = intId;
                             }
                         }
+
+                        version += maxEventId * 100;
                     }
                     catch (Exception e)
                     {
@@ -2022,8 +2027,8 @@ public int Version
 
         /// <summary>
         /// Returns true if the current manifest is better to use than 'otherManifest'   A manifest is
-        /// better if it has a larger version nubmer OR, they have the same version number and it is
-        /// physically larger (we assume what happend is people added more properties but did not
+        /// better if it has a larger version number OR, they have the same version number and it is
+        /// physically larger (we assume what happened is people added more properties but did not
         /// update the version field appropriately).  
         /// </summary>
         public bool BetterThan(ProviderManifest otherManifest)
@@ -2088,7 +2093,6 @@ internal void ParseProviderEvents(Func<DynamicTraceEventData, EventFilterRespons
             Init();
             try
             {
-                version = 0;
                 Dictionary<string, int> opcodes = new Dictionary<string, int>();
                 opcodes.Add("win:Info", 0);
                 opcodes.Add("win:Start", 1);
@@ -2143,14 +2147,6 @@ internal void ParseProviderEvents(Func<DynamicTraceEventData, EventFilterRespons
                                     int taskNum = 0;
                                     Guid taskGuid = Guid.Empty;
 
-                                    version++;
-                                    string ver = reader.GetAttribute("version");
-                                    int intVer;
-                                    if (ver != null && int.TryParse(ver, out intVer))
-                                    {
-                                        version += intVer;
-                                    }
-
                                     int eventID = int.Parse(reader.GetAttribute("value"));
                                     int opcode = 0;
                                     string opcodeName = reader.GetAttribute("opcode");

src/TraceEvent/Parsers/TplTraceEventParser.cs

@@ -26,7 +26,8 @@ public enum Keywords : long
             Asynccausalitysynchronouswork = 0x20,
             Taskstops = 0x40,
             TasksFlowActivityIds = 0x80,
-            Default = Tasktransfer | Tasks | Parallel | Asynccausalityoperation | Asynccausalityrelation | Asynccausalitysynchronouswork | Taskstops | TasksFlowActivityIds,
+            AsyncMethod = 0x100,
+            Default = Tasktransfer | Tasks | Parallel | Asynccausalityoperation | Asynccausalityrelation | Asynccausalitysynchronouswork | Taskstops | TasksFlowActivityIds | AsyncMethod, 
         };
 
         public TplEtwProviderTraceEventParser(TraceEventSource source) : base(source) { }
@@ -229,6 +230,17 @@ public event Action<TraceSynchronousWorkStopArgs> TraceSynchronousWorkStop
                 source.UnregisterEventTemplate(value, 18, ProviderGuid);
             }
         }
+        public event Action<IncompleteAsyncMethodArgs> IncompleteAsyncMethod
+        {
+            add
+            {
+                source.RegisterEventTemplate(IncompleteAsyncMethodTemplate(value));
+            }
+            remove
+            {
+                source.UnregisterEventTemplate(value, 27, ProviderGuid);
+            }
+        }
 
         #region private
         protected override string GetProviderName() { return ProviderName; }
@@ -305,13 +317,17 @@ static private TraceSynchronousWorkStopArgs TraceSynchronousWorkStopTemplate(Act
         {                  // action, eventid, taskid, taskName, taskGuid, opcode, opcodeName, providerGuid, providerName
             return new TraceSynchronousWorkStopArgs(action, 18, 9, "TraceSynchronousWork", Guid.Empty, 2, "Stop", ProviderGuid, ProviderName);
         }
-
+        static private IncompleteAsyncMethodArgs IncompleteAsyncMethodTemplate(Action<IncompleteAsyncMethodArgs> action)
+        {                  // action, eventid, taskid, taskName, taskGuid, opcode, opcodeName, providerGuid, providerName
+            return new IncompleteAsyncMethodArgs(action, 27, 65507, "IncompleteAsyncMethod", Guid.Empty, 0, "", ProviderGuid, ProviderName);
+        }
+        
         static private volatile TraceEvent[] s_templates;
         protected internal override void EnumerateTemplates(Func<string, string, EventFilterResponse> eventsToObserve, Action<TraceEvent> callback)
         {
             if (s_templates == null)
             {
-                var templates = new TraceEvent[18];
+                var templates = new TraceEvent[19];
                 templates[0] = LoopStartTemplate(null);
                 templates[1] = LoopStopTemplate(null);
                 templates[2] = InvokeStartTemplate(null);
@@ -330,6 +346,8 @@ protected internal override void EnumerateTemplates(Func<string, string, EventFi
                 templates[15] = TraceOperationStopTemplate(null);
                 templates[16] = TraceSynchronousWorkStartTemplate(null);
                 templates[17] = TraceSynchronousWorkStopTemplate(null);
+                templates[18] = IncompleteAsyncMethodTemplate(null);
+
                 s_templates = templates;
             }
             foreach (var template in s_templates)
@@ -1583,6 +1601,67 @@ public override object PayloadValue(int index)
         private event Action<TraceSynchronousWorkStopArgs> m_target;
         #endregion
     }
+    public sealed class IncompleteAsyncMethodArgs : TraceEvent
+    {
+        public string stateMachineDescription { get { return GetUnicodeStringAt(0); } }
+
+        #region Private
+        internal IncompleteAsyncMethodArgs(Action<IncompleteAsyncMethodArgs> target, int eventID, int task, string taskName, Guid taskGuid, int opcode, string opcodeName, Guid providerGuid, string providerName)
+            : base(eventID, task, taskName, taskGuid, opcode, opcodeName, providerGuid, providerName)
+        {
+            this.m_target = target;
+        }
+        protected internal override void Dispatch()
+        {
+            m_target(this);
+        }
+        protected internal override void Validate()
+        {
+            Debug.Assert(!(Version == 0 && EventDataLength != SkipUnicodeString(0)));
+            Debug.Assert(!(Version > 0 && EventDataLength < SkipUnicodeString(0)));
+        }
+        protected internal override Delegate Target
+        {
+            get { return m_target; }
+            set { m_target = (Action<IncompleteAsyncMethodArgs>)value; }
+        }
+        public override StringBuilder ToXml(StringBuilder sb)
+        {
+            Prefix(sb);
+            XmlAttrib(sb, "stateMachineDescription", stateMachineDescription);
+            sb.Append("/>");
+            return sb;
+        }
+
+        public override string[] PayloadNames
+        {
+            get
+            {
+                if (payloadNames == null)
+                    payloadNames = new string[] { "stateMachineDescription" };
+                return payloadNames;
+            }
+        }
+
+        public override object PayloadValue(int index)
+        {
+            switch (index)
+            {
+                case 0:
+                    return stateMachineDescription;
+                default:
+                    Debug.Assert(false, "Bad field index");
+                    return null;
+            }
+        }
+
+        public static ulong GetKeywords() { return 256; }
+        public static string GetProviderName() { return "System.Threading.Tasks.TplEventSource"; }
+        public static Guid GetProviderGuid() { return new Guid("2e5dba47-a3d2-4d16-8ee0-6671ffdcd7b5"); }
+        private event Action<IncompleteAsyncMethodArgs> m_target;
+        #endregion
+    }
+
     public enum AsyncCausalityStatus
     {
         Started = 0x0,

src/TraceEvent/TraceEventSession.cs

@@ -2581,7 +2581,7 @@ public static unsafe bool MaybeAnEventSource(Guid providerGuid)
                 return true;
             }
             // FrameworkEventSource predated the Guid selection convention that most eventSources use.  
-            // Opt it in explicity 
+            // Opt it in explicitly 
             if (providerGuid == FrameworkEventSourceTraceEventParser.ProviderGuid)
             {
                 return true;