private async Task <Stream> GetLogsAsync(Action <EventLogsPipelineSettings> settingsCallback = null)
{
var outputStream = new MemoryStream();
await using (var testExecution = StartTraceeProcess(LoggerRemoteTestName))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
using var loggerFactory = new LoggerFactory(new[] { new TestStreamingLoggerProvider(outputStream) });
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
var logSettings = new EventLogsPipelineSettings {
Duration = Timeout.InfiniteTimeSpan
};
if (null != settingsCallback)
{
settingsCallback(logSettings);
}
await using var pipeline = new EventLogsPipeline(client, logSettings, loggerFactory);
await PipelineTestUtilities.ExecutePipelineWithDebugee(_output, pipeline, testExecution);
}
outputStream.Position = 0L;
return(outputStream);
}
public async Task TestLogs()
{
var outputStream = new MemoryStream();
await using (var testExecution = StartTraceeProcess("LoggerRemoteTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
using var loggerFactory = new LoggerFactory(new[] { new TestStreamingLoggerProvider(outputStream) });
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
var logSettings = new EventLogsPipelineSettings {
Duration = Timeout.InfiniteTimeSpan
};
await using var pipeline = new EventLogsPipeline(client, logSettings, loggerFactory);
await PipelineTestUtilities.ExecutePipelineWithDebugee(pipeline, testExecution);
}
outputStream.Position = 0L;
Assert.True(outputStream.Length > 0, "No data written by logging process.");
using var reader = new StreamReader(outputStream);
string firstMessage = reader.ReadLine();
Assert.NotNull(firstMessage);
LoggerTestResult result = JsonSerializer.Deserialize <LoggerTestResult>(firstMessage);
Assert.Equal("Some warning message with 6", result.Message);
Assert.Equal("LoggerRemoteTest", result.Category);
Assert.Equal("Warning", result.LogLevel);
Assert.Equal("0", result.EventId);
Validate(result.Scopes, ("BoolValue", "true"), ("StringValue", "test"), ("IntValue", "5"));
Validate(result.Arguments, ("arg", "6"));
string secondMessage = reader.ReadLine();
Assert.NotNull(secondMessage);
result = JsonSerializer.Deserialize <LoggerTestResult>(secondMessage);
Assert.Equal("Another message", result.Message);
Assert.Equal("LoggerRemoteTest", result.Category);
Assert.Equal("Warning", result.LogLevel);
Assert.Equal("0", result.EventId);
Assert.Equal(0, result.Scopes.Count);
//We are expecting only the original format
Assert.Equal(1, result.Arguments.Count);
}
public async Task TestTraceStopAsync()
{
Stream eventStream = null;
await using (var testExecution = StartTraceeProcess("TraceStopTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
var settings = new EventTracePipelineSettings()
{
Duration = Timeout.InfiniteTimeSpan,
Configuration = new CpuProfileConfiguration()
};
var foundProviderSource = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
await using var pipeline = new EventTracePipeline(client, settings, async(s, token) =>
{
eventStream = s;
using var eventSource = new EventPipeEventSource(s);
// Dispose event source when cancelled.
using var _ = token.Register(() => eventSource.Dispose());
eventSource.Dynamic.All += (TraceEvent obj) =>
{
if (string.Equals(obj.ProviderName, MonitoringSourceConfiguration.SampleProfilerProviderName, StringComparison.OrdinalIgnoreCase))
{
foundProviderSource.TrySetResult(null);
}
};
await Task.Run(() => Assert.True(eventSource.Process()), token);
});
await PipelineTestUtilities.ExecutePipelineWithDebugee(
_output,
pipeline,
testExecution,
foundProviderSource);
}
//Validate that the stream is only valid for the lifetime of the callback in the trace pipeline.
Assert.Throws <ObjectDisposedException>(() => eventStream.Read(new byte[4], 0, 4));
}
public async Task TestCounterEventPipeline()
{
var expectedCounters = new[] { "cpu-usage", "working-set" };
string expectedProvider = "System.Runtime";
IDictionary <string, IEnumerable <string> > expectedMap = new Dictionary <string, IEnumerable <string> >();
expectedMap.Add(expectedProvider, expectedCounters);
var foundExpectedCountersSource = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var logger = new TestMetricsLogger(expectedMap, foundExpectedCountersSource);
await using (var testExecution = StartTraceeProcess("CounterRemoteTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
await using EventCounterPipeline pipeline = new EventCounterPipeline(client, new EventPipeCounterPipelineSettings
{
Duration = Timeout.InfiniteTimeSpan,
CounterGroups = new[]
{
new EventPipeCounterGroup
{
ProviderName = expectedProvider,
CounterNames = expectedCounters
}
},
CounterIntervalSeconds = 1
}, new[] { logger });
await PipelineTestUtilities.ExecutePipelineWithDebugee(
_output,
pipeline,
testExecution,
foundExpectedCountersSource);
}
Assert.True(logger.Metrics.Any());
var actualMetrics = logger.Metrics.Select(m => m.Name).OrderBy(m => m);
Assert.Equal(expectedCounters, actualMetrics);
Assert.True(logger.Metrics.All(m => string.Equals(m.Provider, expectedProvider)));
}
public async Task EventCounterTriggerWithEventPipePipelineTest()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
throw new SkipTestException("https://github.com/dotnet/diagnostics/issues/2568");
}
EventCounterTriggerSettings settings = new()
{
ProviderName = EventCounterConstants.RuntimeProviderName,
CounterName = EventCounterConstants.CpuUsageCounterName,
GreaterThan = 5,
SlidingWindowDuration = TimeSpan.FromSeconds(3),
CounterIntervalSeconds = 1
};
await using (var testExecution = StartTraceeProcess("TriggerRemoteTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
DiagnosticsClient client = new(testExecution.TestRunner.Pid);
TaskCompletionSource <object> waitSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
await using EventPipeTriggerPipeline <EventCounterTriggerSettings> pipeline = new(
client,
new EventPipeTriggerPipelineSettings <EventCounterTriggerSettings>
{
Configuration = EventCounterTrigger.CreateConfiguration(settings),
TriggerFactory = new EventCounterTriggerFactory(),
TriggerSettings = settings,
Duration = Timeout.InfiniteTimeSpan
},
traceEvent =>
{
waitSource.TrySetResult(null);
});
await PipelineTestUtilities.ExecutePipelineWithDebugee(
_output,
pipeline,
testExecution,
waitSource);
Assert.True(waitSource.Task.IsCompletedSuccessfully);
}
public async Task TestTraceStopAsync()
{
using var buffer = new MemoryStream();
Stream eventStream = null;
await using (var testExecution = StartTraceeProcess("TraceStopTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
var settings = new EventTracePipelineSettings()
{
Duration = Timeout.InfiniteTimeSpan,
Configuration = new CpuProfileConfiguration()
};
await using var pipeline = new EventTracePipeline(client, settings, async(s, token) =>
{
await s.CopyToAsync(buffer);
eventStream = s;
});
await PipelineTestUtilities.ExecutePipelineWithDebugee(pipeline, testExecution);
}
//Validate that the stream is only valid for the lifetime of the callback in the trace pipeline.
Assert.Throws <ObjectDisposedException>(() => eventStream.Read(new byte[4], 0, 4));
Assert.True(buffer.Length > 0);
var eventSource = new EventPipeEventSource(buffer);
bool foundCpuProvider = false;
eventSource.Dynamic.All += (TraceEvent obj) =>
{
if (string.Equals(obj.ProviderName, MonitoringSourceConfiguration.SampleProfilerProviderName, StringComparison.OrdinalIgnoreCase))
{
foundCpuProvider = true;
}
};
Assert.True(eventSource.Process());
Assert.True(foundCpuProvider);
}
public async Task TestEventStreamCleanup()
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
throw new SkipTestException("Test debugee sigfaults for OSX/Linux");
}
Stream eventStream = null;
using var cancellationTokenSource = new CancellationTokenSource();
await using (var testExecution = StartTraceeProcess("TestEventStreamCleanup"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
var settings = new EventTracePipelineSettings()
{
Duration = Timeout.InfiniteTimeSpan,
Configuration = new CpuProfileConfiguration()
};
await using var pipeline = new EventTracePipeline(client, settings, (s, token) =>
{
eventStream = s; //Clients should not do this.
cancellationTokenSource.Cancel();
token.ThrowIfCancellationRequested();
return(Task.CompletedTask);
});
await Assert.ThrowsAsync <OperationCanceledException>(
async() => await PipelineTestUtilities.ExecutePipelineWithDebugee(
_output,
pipeline,
testExecution,
cancellationTokenSource.Token));
}
//Validate that the stream is only valid for the lifetime of the callback in the trace pipeline.
Assert.Throws <ObjectDisposedException>(() => eventStream.Read(new byte[4], 0, 4));
}
public async Task TestTraceStopAsync()
{
using var buffer = new MemoryStream();
await using (var testExecution = StartTraceeProcess("TraceStopTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
var settings = new EventTracePipelineSettings()
{
Duration = Timeout.InfiniteTimeSpan,
Configuration = new CpuProfileConfiguration()
};
await using var pipeline = new EventTracePipeline(client, settings, async(s, token) =>
{
//The buffer must be read in order to not hang. The Stop message will not be processed otherwise.
await s.CopyToAsync(buffer);
});
await PipelineTestUtilities.ExecutePipelineWithDebugee(pipeline, testExecution);
}
Assert.True(buffer.Length > 0);
var eventSource = new EventPipeEventSource(buffer);
bool foundCpuProvider = false;
eventSource.Dynamic.All += (TraceEvent obj) =>
{
if (string.Equals(obj.ProviderName, MonitoringSourceConfiguration.SampleProfilerProviderName, StringComparison.OrdinalIgnoreCase))
{
foundCpuProvider = true;
}
};
Assert.True(eventSource.Process());
Assert.True(foundCpuProvider);
}
public async Task TestCounterEventPipeline()
{
var logger = new TestMetricsLogger(_output);
var expectedCounters = new[] { "cpu-usage", "working-set" };
string expectedProvider = "System.Runtime";
await using (var testExecution = StartTraceeProcess("CounterRemoteTest"))
{
//TestRunner should account for start delay to make sure that the diagnostic pipe is available.
var client = new DiagnosticsClient(testExecution.TestRunner.Pid);
await using EventCounterPipeline pipeline = new EventCounterPipeline(client, new EventPipeCounterPipelineSettings
{
Duration = Timeout.InfiniteTimeSpan,
CounterGroups = new[]
{
new EventPipeCounterGroup
{
ProviderName = expectedProvider,
CounterNames = expectedCounters
}
},
RefreshInterval = TimeSpan.FromSeconds(1)
}, new[] { logger });
await PipelineTestUtilities.ExecutePipelineWithDebugee(pipeline, testExecution);
}
Assert.True(logger.Metrics.Any());
var actualMetrics = logger.Metrics.Select(m => m.Name).OrderBy(m => m);
Assert.Equal(expectedCounters, actualMetrics);
Assert.True(logger.Metrics.All(m => string.Equals(m.Provider, expectedProvider)));
}