Dotnet-trace (.netrace) support

DotNetEventPipe/DataOutputTypes/GenericEvent.cs

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using Microsoft.Diagnostics.Tracing;
+using Microsoft.Diagnostics.Tracing.Etlx;
+using Microsoft.Performance.SDK;
+using System;
+using Utilities;
+
+namespace DotNetEventPipe.DataOutputTypes
+{
+    /// <summary>
+    /// A GenericEvent
+    /// </summary>
+    public class GenericEvent
+    {
+        public string EventName { get; }
+        public TraceEventID ID { get; }
+        public TraceEventKeyword Keywords { get; }
+        public TraceEventLevel Level { get; }
+        public TraceEventOpcode Opcode { get; }
+        public string OpcodeName { get; }
+        public string[] PayloadNames { get; }
+        public object[] PayloadValues { get; }
+        public Guid ProviderGuid { get; }
+        public string ProviderName { get; }
+        public int ProcessID { get; }
+        public string ProcessName { get; }
+        public int ProcessorNumber { get; }
+        public int ThreadID { get; }
+        public Timestamp Timestamp { get; }
+        public string[] CallStack { get; }
+        /// <summary>
+        /// filename of the binary / library for the instruction pointer
+        /// </summary>
+        public TraceModuleFile Module { get; }
+        /// <summary>
+        /// Functionname of the instruction pointer
+        /// </summary>
+        public string FullMethodName { get; }
+
+        public GenericEvent(string eventName, TraceEventID id, TraceEventKeyword keywords, TraceEventLevel level, TraceEventOpcode opcode, string opcodeName, string[] payloadNames, object[] payloadValues, Guid providerGuid, string providerName, int processID, string processName, int processorNumber, int threadID, Timestamp timestamp, string[] callStack, TraceModuleFile module, string fullMethodName)
+        {
+            EventName = Common.StringIntern(eventName);
+            ID = id;
+            Keywords = keywords;
+            Level = level;
+            Opcode = opcode;
+            OpcodeName = Common.StringIntern(opcodeName);
+            PayloadNames = payloadNames;
+            PayloadValues = payloadValues;
+            ProviderGuid = providerGuid;
+            ProviderName = providerName;
+            ProcessID = processID;
+            ProcessName = Common.StringIntern(processName);
+            ProcessorNumber = processorNumber;
+            ThreadID = threadID;
+            Timestamp = timestamp;
+            CallStack = callStack;
+            Module = module;
+            FullMethodName = Common.StringIntern(fullMethodName);
+        }
+    }
+}

DotNetEventPipe/DataOutputTypes/ThreadSamplingEvent.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using Microsoft.Diagnostics.Tracing.Etlx;
+using Microsoft.Performance.SDK;
+using Utilities;
+
+namespace DotNetEventPipe.DataOutputTypes
+{
+    /// <summary>
+    /// A CPU sampling event that samples at some interval
+    /// Shows process and threads, and stacks that were running on which CPUs at specific times.
+    /// </summary>
+    public readonly struct ThreadSamplingEvent
+    {
+        public int ProcessID { get; }
+        public string ProcessName { get; }
+        public int ProcessorNumber { get; }
+        public int ThreadID { get; }
+        public Timestamp Timestamp { get; }
+        public string[] CallStack { get; }
+        /// <summary>
+        /// filename of the binary / library for the instruction pointer
+        /// </summary>
+        public TraceModuleFile Module { get; }
+        /// <summary>
+        /// Functionname of the instruction pointer
+        /// </summary>
+        public string FullMethodName { get; }
+
+        public ThreadSamplingEvent(
+            int processID,
+            string processName,
+            int processorNumber,
+            int threadID,
+            Timestamp timestamp,
+            string[] callStack,
+            TraceModuleFile module,
+            string fullMethodName
+            )
+        {
+            ProcessID = processID;
+            ProcessName = Common.StringIntern(processName);
+            ProcessorNumber = processorNumber;
+            ThreadID = threadID;
+            Timestamp = timestamp;
+            CallStack = callStack; // Cache whole common stack??
+            Module = module;
+            FullMethodName = Common.StringIntern(fullMethodName);
+        }
+    }
+}

DotNetEventPipe/DataOutputTypes/TraceCallStackProcessed.cs

@@ -0,0 +1,14 @@
+using Microsoft.Diagnostics.Tracing.Etlx;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DotnetEventpipe.DataOutputTypes
+{
+    public class TraceCallStackProcessed
+    {
+        public string[] CallStack { get; set; }
+        public TraceModuleFile Module { get; set; }
+        public string FullMethodName { get; set; }
+    }
+}

DotNetEventPipe/DotnetEventpipe.csproj

@@ -0,0 +1,52 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+	<Version>1.0.0</Version>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <Authors>Microsoft</Authors>
+    <Company>Microsoft Corp.</Company>
+    <Product>Performance ToolKit</Product>
+    <Description>Contains the .NET Trace datasource plugin.</Description>
+    <PackageId>Microsoft.Performance.Toolkit.Plugins.DotNetEvent</PackageId>
+    <Copyright>© Microsoft Corporation. All rights reserved.</Copyright>
+    <RepositoryUrl>https://github.com/microsoft/Microsoft-Performance-Tools-Linux-Android</RepositoryUrl>
+    <PackageProjectUrl>https://github.com/microsoft/Microsoft-Performance-Tools-Linux-Android</PackageProjectUrl>
+    <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DefineConstants>TRACE</DefineConstants>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\LICENSE.txt">
+      <Pack>True</Pack>
+      <PackagePath></PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Diagnostics.Tracing.TraceEvent" Version="3.0.0">
+      <GeneratePathProperty>True</GeneratePathProperty>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Performance.SDK" Version="1.0.16" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Utilities\Utilities.csproj" />
+  </ItemGroup>
+
+<ItemGroup>
+  <TraceEventWorkaround Include="$(PkgMicrosoft_Diagnostics_Tracing_Traceevent)\lib\netstandard2.0\Microsoft.Diagnostics.Tracing.TraceEvent.dll;$(PkgMicrosoft_Diagnostics_Tracing_Traceevent)\lib\netstandard2.0\Microsoft.Diagnostics.FastSerialization.dll" />
+</ItemGroup>
+<Target Name="CopyRulesToTarget" AfterTargets="Build">
+  <Copy SourceFiles="@(TraceEventWorkaround)" DestinationFolder="$(TargetDir)" />
+</Target>
+
+</Project>

DotNetEventPipe/SourceDataCookers/DotnetTraceDataProcessor.cs

@@ -0,0 +1,111 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using DotNetEventPipe.Tables;
+using Microsoft.Diagnostics.Tracing;
+using Microsoft.Performance.SDK.Processing;
+using Microsoft.Diagnostics.Tracing.EventPipe;
+using Microsoft.Diagnostics.Tracing.Etlx;
+
+namespace DotNetEventPipe
+{
+    public sealed class DotnetTraceDataProcessor
+        : CustomDataProcessor
+    {
+        private readonly string[] filePaths;
+        private IReadOnlyDictionary<string, TraceEventProcessor> fileContent;
+        private DataSourceInfo dataSourceInfo;
+
+        public DotnetTraceDataProcessor(
+           string[] filePaths,
+           ProcessorOptions options,
+           IApplicationEnvironment applicationEnvironment,
+           IProcessorEnvironment processorEnvironment)
+            : base(options, applicationEnvironment, processorEnvironment)
+        {
+            //
+            // Assign the files array to a readonly backing field.
+            //
+
+            this.filePaths = filePaths;
+        }
+
+        public override DataSourceInfo GetDataSourceInfo()
+        {
+            // The DataSourceInfo is used to tell analzyer the time range of the data(if applicable) and any other relevant data for rendering / synchronizing.
+
+            return this.dataSourceInfo;
+
+        }
+
+        protected override Task ProcessAsyncCore(
+           IProgress<int> progress,
+           CancellationToken cancellationToken)
+        {
+            var contentDictionary = new Dictionary<string, TraceEventProcessor>();
+
+            foreach (var path in this.filePaths)
+            {
+                var traceStartTime = DateTime.UtcNow.Date;
+
+                // EventPipeEventSource doesn't expose the callstacks - https://github.com/Microsoft/perfview/blob/main/src/TraceEvent/EventPipe/EventPipeFormat.md
+                // But currently it's SessionDuration, SessionStartTime are correct
+                // Can remove when when this is released - https://github.com/microsoft/perfview/pull/1635
+                var dotnetFileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+                using (var traceSource = new EventPipeEventSource(dotnetFileStream))
+                {
+                    traceSource.Process();
+                    this.dataSourceInfo = new DataSourceInfo(0, traceSource.SessionDuration.Ticks * 100, traceSource.SessionStartTime.ToUniversalTime());
+                }
+
+                var tmpEtlx = Path.Combine(Path.GetTempPath(), Path.GetFileName(path) + ".etlx");
+
+                string traceLogPath = TraceLog.CreateFromEventPipeDataFile(path, tmpEtlx);
+                using (TraceLog traceLog = new TraceLog(traceLogPath))
+                {
+                    TraceLogEventSource source = traceLog.Events.GetSource();
+
+                    var traceEventProcessor = new TraceEventProcessor();
+                    contentDictionary[path] = traceEventProcessor;
+                    source.AllEvents += traceEventProcessor.ProcessTraceEvent;
+                    source.Process();
+                    // Below will work when this is released - https://github.com/microsoft/perfview/pull/1635
+                    //this.dataSourceInfo = new DataSourceInfo(0, source.SessionDuration.Ticks * 100, source.SessionStartTime.ToUniversalTime());
+                }
+                File.Delete(tmpEtlx);
+            }
+
+            this.fileContent = new ReadOnlyDictionary<string, TraceEventProcessor>(contentDictionary);
+
+            return Task.CompletedTask;
+        }
+
+        protected override void BuildTableCore(
+            TableDescriptor tableDescriptor,
+            ITableBuilder tableBuilder)
+        {
+            //
+            // Instantiate the table, and pass the tableBuilder to it.
+            //
+
+            var table = this.InstantiateTable(tableDescriptor.Type);
+            table.Build(tableBuilder);
+        }
+
+        private TraceEventTableBase InstantiateTable(Type tableType)
+        {
+            //
+            // This private method is added to activate the given table type and pass in the file content.
+            //
+
+            var instance = Activator.CreateInstance(tableType, new[] { this.fileContent, });
+            return (TraceEventTableBase)instance;
+        }
+    }
+}

DotNetEventPipe/SourceDataCookers/DotnetTraceProcessingSource.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.Performance.SDK.Processing;
+
+namespace DotNetEventPipe
+{
+    [ProcessingSource(
+        "{890C0A11-011E-43E1-AE28-7E1A903A6633}",   // The GUID must be unique for your Custom Data Source. You can use Visual Studio's Tools -> Create Guid… tool to create a new GUID
+        ".NET (dotnet-trace)",                      // The Custom Data Source MUST have a name
+        @".net trace EventPipe")]                   // The Custom Data Source MUST have a description
+    [FileDataSource(
+        ".nettrace",                                // A file extension is REQUIRED
+        "dotnet-trace")]                            // A description is OPTIONAL. The description is what appears in the file open menu to help users understand what the file type actually is. 
+
+    //
+    // There are two methods to creating a Custom Data Source that is recognized by UI:
+    //    1. Using the helper abstract base classes
+    //    2. Implementing the raw interfaces
+    // This sample demonstrates method 1 where the ProcessingSource abstract class
+    // helps provide a public parameterless constructor and implement the IProcessingSource interface
+    //
+
+    public class DotnetTraceProcessingSource
+        : ProcessingSource
+    {
+        private IApplicationEnvironment applicationEnvironment;
+
+        public override ProcessingSourceInfo GetAboutInfo()
+        {
+            return new ProcessingSourceInfo()
+            {
+                ProjectInfo = new ProjectInfo() { Uri = "https://aka.ms/linuxperftools" },
+            };
+        }
+
+        protected override void SetApplicationEnvironmentCore(IApplicationEnvironment applicationEnvironment)
+        {
+            //
+            // Saves the given application environment into this instance
+            //
+
+            this.applicationEnvironment = applicationEnvironment;
+        }
+
+        protected override bool IsDataSourceSupportedCore(IDataSource dataSource)
+        {
+            return dataSource.IsFile() && Path.GetExtension(dataSource.Uri.LocalPath) == ".nettrace";
+        }
+
+        protected override ICustomDataProcessor CreateProcessorCore(
+            IEnumerable<IDataSource> dataSources,
+            IProcessorEnvironment processorEnvironment,
+            ProcessorOptions options)
+        {
+            //
+            // Create a new instance implementing ICustomDataProcessor here to process the specified data sources.
+            // Note that you can have more advanced logic here to create different processors if you would like based on the file, or any other criteria.
+            // You are not restricted to always returning the same type from this method.
+            //
+
+            return new DotnetTraceDataProcessor(
+                dataSources.Select(x => x.Uri.LocalPath).ToArray(),
+                options,
+                this.applicationEnvironment,
+                processorEnvironment);
+        }
+    }
+}