private EventPipeProvider[] GetEventPipeProviders()
{
// EventSources support EventCounter based metrics directly
IEnumerable <EventPipeProvider> eventCounterProviders = _counterList.Providers.Select(
providerName => new EventPipeProvider(providerName, EventLevel.Error, 0, new Dictionary <string, string>()
{
{ "EventCounterIntervalSec", _interval.ToString() }
}));
//System.Diagnostics.Metrics EventSource supports the new Meter/Instrument APIs
const long TimeSeriesValues = 0x2;
StringBuilder metrics = new StringBuilder();
foreach (string provider in _counterList.Providers)
{
if (metrics.Length != 0)
{
metrics.Append(",");
}
if (_counterList.IncludesAllCounters(provider))
{
metrics.Append(provider);
}
else
{
string[] providerCounters = _counterList.GetCounters(provider).Select(counter => $"{provider}\\{counter}").ToArray();
metrics.Append(string.Join(',', providerCounters));
}
}
EventPipeProvider metricsEventSourceProvider =
new EventPipeProvider("System.Diagnostics.Metrics", EventLevel.Informational, TimeSeriesValues,
new Dictionary <string, string>()
{
{ "SessionId", _metricsEventSourceSessionId },
{ "Metrics", metrics.ToString() },
{ "RefreshInterval", _interval.ToString() },
{ "MaxTimeSeries", _maxTimeSeries.ToString() },
{ "MaxHistograms", _maxHistograms.ToString() }
}
);
return(eventCounterProviders.Append(metricsEventSourceProvider).ToArray());
}
public void ProvidersWithComplexFilters_CorrectlyParse()
{
string providersToParse = @"MyProvider:::A=B;C=D";
List <EventPipeProvider> parsedProviders = Extensions.ToProviders(providersToParse);
Assert.Single(parsedProviders);
EventPipeProvider providerOne = parsedProviders[0];
Assert.Equal("MyProvider", providerOne.Name);
Assert.Equal(2, providerOne.Arguments.Count);
Assert.Equal("B", providerOne.Arguments["A"]);
Assert.Equal("D", providerOne.Arguments["C"]);
providersToParse = @"MyProvider:::A=B;C=""D"",MyProvider2:::A=1;B=2;";
parsedProviders = Extensions.ToProviders(providersToParse);
Assert.Equal(2, parsedProviders.Count);
providerOne = parsedProviders[0];
EventPipeProvider providerTwo = parsedProviders[1];
Assert.Equal("MyProvider", providerOne.Name);
Assert.Equal("MyProvider2", providerTwo.Name);
Assert.Equal(2, providerOne.Arguments.Count);
Assert.Equal("B", providerOne.Arguments["A"]);
Assert.Equal("D", providerOne.Arguments["C"]);
Assert.Equal(2, providerTwo.Arguments.Count);
Assert.Equal("1", providerTwo.Arguments["A"]);
Assert.Equal("2", providerTwo.Arguments["B"]);
providersToParse = @"MyProvider:::A=""B;C=D"",MyProvider2:::A=""spaced words"";C=1285;D=Spaced Words 2";
parsedProviders = Extensions.ToProviders(providersToParse);
Assert.Equal(2, parsedProviders.Count);
providerOne = parsedProviders[0];
providerTwo = parsedProviders[1];
Assert.Equal("MyProvider", providerOne.Name);
Assert.Equal("MyProvider2", providerTwo.Name);
Assert.Equal(1, providerOne.Arguments.Count);
Assert.Equal(3, providerTwo.Arguments.Count);
Assert.Equal("B;C=D", providerOne.Arguments["A"]);
Assert.Equal("spaced words", providerTwo.Arguments["A"]);
Assert.Equal("Spaced Words 2", providerTwo.Arguments["D"]);
Assert.Equal("1285", providerTwo.Arguments["C"]);
}
public static bool ValidateProvider(GlobalCounterOptions counterOptions,
EventPipeProvider provider,
out string errorMessage)
{
errorMessage = null;
if (provider.Arguments?.TryGetValue("EventCounterIntervalSec", out string intervalValue) == true)
{
if (float.TryParse(intervalValue, out float intervalSeconds) &&
intervalSeconds != counterOptions.GetIntervalSeconds())
{
errorMessage = string.Format(CultureInfo.CurrentCulture,
Strings.ErrorMessage_InvalidMetricInterval,
provider.Name,
counterOptions.GetIntervalSeconds());
return(false);
}
}
return(true);
}
public void UserSettingsOverrideDefaultSettings()
{
const string DotNetRuntime = "Microsoft-Windows-DotNETRuntime";
var defaultSettings = new EventPipeProvider(
DotNetRuntime,
EventLevel.Informational,
(long)ClrTraceEventParser.Keywords.Default);
var userSettings = new EventPipeProvider(
DotNetRuntime,
EventLevel.Verbose,
(long)(ClrTraceEventParser.Keywords.Default | ClrTraceEventParser.Keywords.JitTracing));
var result = EventPipeProfiler.MapToProviders(EventPipeProfile.CpuSampling, new[] { userSettings });
var final = result.Single(x => x.Name == userSettings.Name);
Assert.Equal(userSettings.EventLevel, final.EventLevel);
Assert.Equal(userSettings.Keywords, final.Keywords);
Assert.Contains(SampleProfiler, result);
}
public void Start(string providerName, EventLevel level, long keywords)
{
var provider = new EventPipeProvider(providerName, level, keywords);
m_session = m_client.StartEventPipeSession(new List <EventPipeProvider>()
{
provider
});
// Task that reads and does nothing
Task streamTask = Task.Run(() =>
{
var buffer = new byte[1000];
while (true)
{
try
{
m_session.EventStream.Read(buffer, 0, 1000);
}
catch (Exception e)
{
}
}
});
}
private static string GetProviderDisplayString(EventPipeProvider provider) =>
String.Format("{0, -40}", provider.Name) + String.Format("0x{0, -18}", $"{provider.Keywords:X16}") + String.Format("{0, -8}", provider.EventLevel.ToString() + $"({(int)provider.EventLevel})");
