[UserEvents] Add end-to-end runtime test

eng/Versions.props

@@ -109,7 +109,7 @@
     <!-- Not auto-updated. -->
     <MicrosoftDiaSymReaderVersion>2.0.0</MicrosoftDiaSymReaderVersion>
     <MicrosoftDiaSymReaderNativeVersion>17.10.0-beta1.24272.1</MicrosoftDiaSymReaderNativeVersion>
-    <TraceEventVersion>3.1.16</TraceEventVersion>
+    <TraceEventVersion>3.1.28</TraceEventVersion>
     <MicrosoftDiagnosticsNetCoreClientVersion>0.2.621003</MicrosoftDiagnosticsNetCoreClientVersion>
     <NETStandardLibraryRefVersion>2.1.0</NETStandardLibraryRefVersion>
     <NetStandardLibraryVersion>2.0.3</NetStandardLibraryVersion>
@@ -124,6 +124,7 @@
     <!-- Testing -->
     <MicrosoftNETCoreCoreDisToolsVersion>1.6.0</MicrosoftNETCoreCoreDisToolsVersion>
     <MicrosoftNETTestSdkVersion>17.4.0-preview-20220707-01</MicrosoftNETTestSdkVersion>
+    <MicrosoftOneCollectRecordTraceVersion>0.1.32221</MicrosoftOneCollectRecordTraceVersion>
     <NUnitVersion>3.12.0</NUnitVersion>
     <NUnit3TestAdapterVersion>4.5.0</NUnit3TestAdapterVersion>
     <CoverletCollectorVersion>6.0.4</CoverletCollectorVersion>

src/tests/tracing/eventpipe/userevents/dotnet-common.script

@@ -0,0 +1,2 @@
+let Microsoft_Windows_DotNETRuntime_flags = new_dotnet_provider_flags();
+record_dotnet_provider("Microsoft-Windows-DotNETRuntime", 0x100003801D, 4, Microsoft_Windows_DotNETRuntime_flags);

src/tests/tracing/eventpipe/userevents/userevents.cs

@@ -0,0 +1,120 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Threading;
+using Microsoft.Diagnostics.Tracing;
+using Microsoft.Diagnostics.Tracing.Etlx;
+
+namespace Tracing.Tests.UserEvents
+{
+    public class UserEventsTest
+    {
+        private static readonly string trace = "trace.nettrace";
+        private const int SIGINT = 2;
+
+        [DllImport("libc", SetLastError = true)]
+        private static extern int kill(int pid, int sig);
+
+        public static int Main(string[] args)
+        {
+            if (args.Length > 0 && args[0] == "tracee")
+            {
+                UserEventsTracee.Run();
+                return 0;
+            }
+
+            return TestEntryPoint();
+        }
+
+        public static int TestEntryPoint()
+        {
+            string appBaseDir = AppContext.BaseDirectory;
+            string recordTracePath = Path.Combine(appBaseDir, "record-trace");
+            string scriptFilePath = Path.Combine(appBaseDir, "dotnet-common.script");
+            string traceFilePath = Path.Combine(appBaseDir, trace);
+
+            if (!File.Exists(recordTracePath) || !File.Exists(scriptFilePath))
+            {
+                Console.WriteLine("record-trace or dotnet-common.script not found. Test cannot run.");
+                return -1;
+            }
+
+            ProcessStartInfo traceeStartInfo = new();
+            traceeStartInfo.FileName = Process.GetCurrentProcess().MainModule.FileName;
+            traceeStartInfo.Arguments = $"{typeof(UserEventsTest).Assembly.Location} tracee";
+            traceeStartInfo.WorkingDirectory = appBaseDir;
+
+            ProcessStartInfo recordTraceStartInfo = new();
+            recordTraceStartInfo.FileName = recordTracePath;
+            recordTraceStartInfo.Arguments = $"--script-file {scriptFilePath}";
+            recordTraceStartInfo.WorkingDirectory = appBaseDir;
+            recordTraceStartInfo.RedirectStandardOutput = true;
+            recordTraceStartInfo.RedirectStandardError = true;
+
+            using Process traceeProcess = Process.Start(traceeStartInfo);
+            using Process recordTraceProcess = Process.Start(recordTraceStartInfo);
+            recordTraceProcess.OutputDataReceived += (_, args) => Console.WriteLine($"[record-trace] {args.Data}");
+            recordTraceProcess.BeginOutputReadLine();
+            recordTraceProcess.ErrorDataReceived += (_, args) => Console.Error.WriteLine($"[record-trace] {args.Data}");
+            recordTraceProcess.BeginErrorReadLine();
+
+            if (!traceeProcess.HasExited && !traceeProcess.WaitForExit(15000))
+            {
+                traceeProcess.Kill();
+            }
+
+            // Until record-trace supports duration, the only way to stop it is to send SIGINT (ctrl+c)
+            kill(recordTraceProcess.Id, SIGINT);
+            if (!recordTraceProcess.HasExited && !recordTraceProcess.WaitForExit(20000))
+            {
+                // record-trace needs to stop gracefully to generate the trace file
+                recordTraceProcess.Kill();
+            }
+
+            if (!File.Exists(traceFilePath))
+            {
+                Console.Error.WriteLine($"Expected trace file not found at `{traceFilePath}`");
+                return -1;
+            }
+
+            if (!ValidateTraceeEvents(traceFilePath))
+            {
+                Console.Error.WriteLine($"Trace file `{traceFilePath}` does not contain expected events.");
+                return -1;
+            }
+
+            return 100;
+        }
+
+        private static bool ValidateTraceeEvents(string traceFilePath)
+        {
+            string etlxPath = TraceLog.CreateFromEventPipeDataFile(traceFilePath);
+            using TraceLog log = new(etlxPath);
+            using TraceLogEventSource source = log.Events.GetSource();
+            bool startEventFound = false;
+            bool stopEventFound = false;
+
+            source.AllEvents += (TraceEvent e) =>
+            {
+                if (e.ProviderName == "Microsoft-Windows-DotNETRuntime")
+                {
+                    if (e.EventName == "GC/Start")
+                    {
+                        startEventFound = true;
+                    }
+                    else if (e.EventName == "GC/Stop")
+                    {
+                        stopEventFound = true;
+                    }
+                }
+            };
+
+            source.Process();
+            return startEventFound && stopEventFound;
+        }
+    }
+}

src/tests/tracing/eventpipe/userevents/userevents.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <CLRTestTargetUnsupported Condition="'$(TargetOS)' != 'linux' or ('$(TargetArchitecture)' != 'x64' and '$(TargetArchitecture)' != 'arm64')">true</CLRTestTargetUnsupported>
+    <RequiresProcessIsolation>true</RequiresProcessIsolation>
+    <ReferenceXUnitWrapperGenerator>false</ReferenceXUnitWrapperGenerator>
+    <IlasmRoundTripIncompatible>true</IlasmRoundTripIncompatible>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <RestoreAdditionalProjectSources>$(RestoreAdditionalProjectSources);https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-diagnostics-tests/nuget/v3/index.json</RestoreAdditionalProjectSources>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.OneCollect.RecordTrace" Version="$(MicrosoftOneCollectRecordTraceVersion)" PrivateAssets="All" Condition="'$(TargetOS)' == 'linux'" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+    <Compile Include="usereventstracee.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="dotnet-common.script" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <Target Name="CopyRecordTraceBinary" AfterTargets="Build" Condition="'$(TargetOS)' == 'linux'">
+    <PropertyGroup>
+      <RecordTracePath>$(NuGetPackageRoot)microsoft.onecollect.recordtrace/$(MicrosoftOneCollectRecordTraceVersion)/runtimes/$(TargetOS)-$(TargetArchitecture)/native/record-trace</RecordTracePath>
+    </PropertyGroup>
+
+    <Copy SourceFiles="$(RecordTracePath)" DestinationFolder="$(OutputPath)" Condition="Exists('$(RecordTracePath)')" />
+    <Error Text="record-trace not found at $(RecordTracePath)" Condition="!Exists('$(RecordTracePath)')" />
+  </Target>
+</Project>

src/tests/tracing/eventpipe/userevents/usereventstracee.cs

@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Tracing.Tests.UserEvents
+{
+    public class UserEventsTracee
+    {
+        private static byte[] s_array;
+
+        public static void Run()
+        {
+            long startTimestamp = Stopwatch.GetTimestamp();
+            long targetTicks = Stopwatch.Frequency * 10; // 10s
+
+            while (Stopwatch.GetTimestamp() - startTimestamp < targetTicks)
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    s_array = new byte[1024 * 10];
+                }
+
+                GC.Collect();
+                Thread.Sleep(100);
+            }
+        }
+    }
+}