public void BasicProcessInfoTest()
{
using TestRunner runner = new TestRunner(CommonHelper.GetTraceePathWithArgs(targetFramework: "net5.0"), output);
runner.Start();
try
{
DiagnosticsClient client = new DiagnosticsClient(runner.Pid);
ProcessInfo processInfo = client.GetProcessInfo();
Assert.NotNull(processInfo);
Assert.Equal(runner.Pid, (int)processInfo.ProcessId);
Assert.NotNull(processInfo.CommandLine);
Assert.NotNull(processInfo.OperatingSystem);
Assert.NotNull(processInfo.ProcessArchitecture);
//Assert.Equal("Tracee", processInfo.ManagedEntrypointAssemblyName);
//Version clrVersion = ParseVersionRemoveLabel(processInfo.ClrProductVersionString);
//Assert.True(clrVersion >= new Version(6, 0, 0));
}
finally
{
runner.PrintStatus();
}
}
private async Task BasicProcessInfoTestCore(bool useAsync, bool suspend)
{
using TestRunner runner = new TestRunner(CommonHelper.GetTraceePathWithArgs(targetFramework: "net5.0"), _output);
if (suspend)
{
runner.SuspendDefaultDiagnosticPort();
}
runner.Start();
try
{
DiagnosticsClientApiShim clientShim = new DiagnosticsClientApiShim(new DiagnosticsClient(runner.Pid), useAsync);
// While suspended, the runtime will not provide entrypoint information.
ProcessInfo processInfoBeforeResume = null;
if (suspend)
{
processInfoBeforeResume = await clientShim.GetProcessInfo();
ValidateProcessInfo(runner.Pid, processInfoBeforeResume);
Assert.True(string.IsNullOrEmpty(processInfoBeforeResume.ManagedEntrypointAssemblyName));
await clientShim.ResumeRuntime();
}
// The entrypoint information is available some short time after the runtime
// begins to execute. Retry getting process information until entrypoint is available.
ProcessInfo processInfo = await GetProcessInfoWithEntrypointAsync(clientShim);
ValidateProcessInfo(runner.Pid, processInfo);
Assert.Equal("Tracee", processInfo.ManagedEntrypointAssemblyName);
// Validate values before resume (except for entrypoint) are the same after resume.
if (suspend)
{
Assert.Equal(processInfoBeforeResume.ProcessId, processInfo.ProcessId);
Assert.Equal(processInfoBeforeResume.RuntimeInstanceCookie, processInfo.RuntimeInstanceCookie);
Assert.Equal(processInfoBeforeResume.CommandLine, processInfo.CommandLine);
Assert.Equal(processInfoBeforeResume.OperatingSystem, processInfo.OperatingSystem);
Assert.Equal(processInfoBeforeResume.ProcessArchitecture, processInfo.ProcessArchitecture);
Assert.Equal(processInfoBeforeResume.ClrProductVersionString, processInfo.ClrProductVersionString);
}
}
finally
{
runner.PrintStatus();
}
}
public void EventPipeSessionStreamTest()
{
TestRunner runner = new TestRunner(CommonHelper.GetTraceePathWithArgs(), output);
runner.Start(3000);
DiagnosticsClient client = new DiagnosticsClient(runner.Pid);
runner.PrintStatus();
output.WriteLine($"[{DateTime.Now.ToString()}] Trying to start an EventPipe session on process {runner.Pid}");
using (var session = client.StartEventPipeSession(new List <EventPipeProvider>()
{
new EventPipeProvider("System.Runtime", EventLevel.Informational, 0, new Dictionary <string, string>()
{
{ "EventCounterIntervalSec", "1" }
})
}))
{
var evntCnt = 0;
Task streamTask = Task.Run(() => {
var source = new EventPipeEventSource(session.EventStream);
source.Dynamic.All += (TraceEvent obj) => {
output.WriteLine("Got an event");
evntCnt += 1;
};
try
{
source.Process();
}
catch (Exception e)
{
// This exception can happen if the target process exits while EventPipeEventSource is in the middle of reading from the pipe.
Console.WriteLine("Error encountered while processing events");
Console.WriteLine(e.ToString());
}
finally
{
runner.Stop();
}
});
output.WriteLine("Waiting for stream Task");
streamTask.Wait(10000);
output.WriteLine("Done waiting for stream Task");
Assert.True(evntCnt > 0);
}
}