public void HandleThreadsEvent_RecordsValues()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new CLRRuntimeObserver(options, stats, tags, null);
CLRRuntimeSource.ThreadMetrics metrics = new CLRRuntimeSource.ThreadMetrics(100, 100, 200, 200);
observer.HandleThreadsEvent(metrics);
var live = stats.ViewManager.GetView(ViewName.Create("clr.threadpool.active"));
var aggData = MetricsHelpers.SumWithTags(live) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(live, new List <ITagValue>()
{
TagValue.Create("worker")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(live, new List <ITagValue>()
{
TagValue.Create("completionPort")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
var avail = stats.ViewManager.GetView(ViewName.Create("clr.threadpool.avail"));
aggData = MetricsHelpers.SumWithTags(avail) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(avail, new List <ITagValue>()
{
TagValue.Create("worker")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(avail, new List <ITagValue>()
{
TagValue.Create("completionPort")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
}
public void ProcessEvent_IgnoresNulls()
{
var options = new MetricsObserverOptions();
var stats = new TestOpenTelemetryMetrics();
var observer = new CLRRuntimeObserver(options, stats, null);
observer.ProcessEvent("foobar", null);
observer.ProcessEvent(CLRRuntimeObserver.HEAP_EVENT, null);
observer.ProcessEvent(CLRRuntimeObserver.THREADS_EVENT, null);
}
public void ProcessEvent_IgnoresNulls()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new CLRRuntimeObserver(options, stats, tags, null);
observer.ProcessEvent("foobar", null);
observer.ProcessEvent(CLRRuntimeObserver.HEAP_EVENT, null);
observer.ProcessEvent(CLRRuntimeObserver.THREADS_EVENT, null);
}
public void Constructor_RegistersExpectedViews()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new CLRRuntimeObserver(options, stats, tags, null);
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.memory.used")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.gc.collections")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.threadpool.active")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.threadpool.avail")));
}
/// <summary>
/// Add Metrics actuator endpoint to OWIN Pipeline
/// </summary>
/// <param name="builder">OWIN <see cref="IAppBuilder" /></param>
/// <param name="config"><see cref="IConfiguration"/> of application for configuring metrics endpoint</param>
/// <param name="stats">Class for recording statistics - See also: <seealso cref="OpenCensusStats"/></param>
/// <param name="tags">Class using for recording statistics</param>
/// <param name="loggerFactory">For logging within the middleware</param>
/// <returns>OWIN <see cref="IAppBuilder" /> with Metrics Endpoint added</returns>
public static IAppBuilder UseMetricsActuator(this IAppBuilder builder, IConfiguration config, IStats stats, ITags tags, ILoggerFactory loggerFactory = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (stats == null)
{
throw new ArgumentNullException(nameof(stats));
}
if (tags == null)
{
throw new ArgumentNullException(nameof(tags));
}
IMetricsOptions options = new MetricsEndpointOptions(config);
var mgmtOptions = ManagementOptions.Get(config);
foreach (var mgmt in mgmtOptions)
{
mgmt.EndpointOptions.Add(options);
}
var hostObserver = new OwinHostingObserver(options, stats, tags, loggerFactory?.CreateLogger <OwinHostingObserver>());
var clrObserver = new CLRRuntimeObserver(options, stats, tags, loggerFactory?.CreateLogger <CLRRuntimeObserver>());
DiagnosticsManager.Instance.Observers.Add(hostObserver);
DiagnosticsManager.Instance.Observers.Add(clrObserver);
var clrSource = new CLRRuntimeSource();
DiagnosticsManager.Instance.Sources.Add(clrSource);
var endpoint = new MetricsEndpoint(options, stats, loggerFactory?.CreateLogger <MetricsEndpoint>());
var logger = loggerFactory?.CreateLogger <MetricsEndpointOwinMiddleware>();
return(builder.Use <MetricsEndpointOwinMiddleware>(endpoint, mgmtOptions, logger));
}
public static void UseMetricsActuator(IConfiguration configuration, ILoggerFactory loggerFactory)
{
var options = new MetricsOptions(configuration);
var hostObserver = new AspNetHostingObserver(options, OpenCensusStats.Instance, OpenCensusTags.Instance, CreateLogger <AspNetHostingObserver>(loggerFactory));
var clrObserver = new CLRRuntimeObserver(options, OpenCensusStats.Instance, OpenCensusTags.Instance, CreateLogger <CLRRuntimeObserver>(loggerFactory));
DiagnosticsManager.Instance.Observers.Add((IDiagnosticObserver)hostObserver);
DiagnosticsManager.Instance.Observers.Add((IDiagnosticObserver)clrObserver);
var clrSource = new CLRRuntimeSource();
DiagnosticsManager.Instance.Sources.Add(clrSource);
var ep = new MetricsEndpoint(options, OpenCensusStats.Instance, CreateLogger <MetricsEndpoint>(loggerFactory));
var handler = new MetricsHandler(ep, SecurityService, CreateLogger <MetricsHandler>(loggerFactory));
ConfiguredHandlers.Add(handler);
}
public void HandleHeapEvent_RecordsValues()
{
var options = new MetricsObserverOptions();
var stats = new TestOpenTelemetryMetrics();
var observer = new CLRRuntimeObserver(options, stats, null);
var factory = stats.Factory;
var metrics = new CLRRuntimeSource.HeapMetrics(1000, new List <long>()
{
10, 20, 30
});
observer.HandleHeapEvent(metrics);
factory.CollectAllMetrics();
var processor = stats.Processor;
var metricName = "clr.memory.used";
var summary = processor.GetMetricByName <long>(metricName);
Assert.NotNull(summary);
var mean = summary.Sum / summary.Count;
Assert.Equal(1000, mean);
Assert.Equal(1000, summary.Min);
Assert.Equal(1000, summary.Max);
metricName = "clr.gc.collections";
var gen0Label = new Dictionary <string, string>()
{
{ "generation", "gen0" }
}.ToList();
summary = processor.GetMetricByName <long>(metricName, gen0Label);
Assert.NotNull(summary);
Assert.Equal(10, summary.Sum);
var gen1Label = new Dictionary <string, string>()
{
{ "generation", "gen1" }
}.ToList();
summary = processor.GetMetricByName <long>(metricName, gen1Label);
Assert.NotNull(summary);
Assert.Equal(20, summary.Sum);
var gen2Label = new Dictionary <string, string>()
{
{ "generation", "gen2" }
}.ToList();
summary = processor.GetMetricByName <long>(metricName, gen2Label);
Assert.NotNull(summary);
Assert.Equal(30, summary.Sum);
processor.Clear();
observer = new CLRRuntimeObserver(options, stats, null);
metrics = new CLRRuntimeSource.HeapMetrics(1000, new List <long>()
{
10, 20, 30
});
observer.HandleHeapEvent(metrics);
metrics = new CLRRuntimeSource.HeapMetrics(5000, new List <long>()
{
15, 25, 30
});
observer.HandleHeapEvent(metrics);
factory.CollectAllMetrics();
metricName = "clr.memory.used";
summary = processor.GetMetricByName <long>(metricName);
Assert.Equal(5000 + 1000, summary.Sum);
Assert.Equal(5000, summary.Max);
Assert.Equal(1000, summary.Min);
metricName = "clr.gc.collections";
summary = processor.GetMetricByName <long>(metricName, gen0Label);
Assert.Equal(15, summary.Sum);
summary = processor.GetMetricByName <long>(metricName, gen1Label);
Assert.NotNull(summary);
Assert.Equal(25, summary.Sum);
summary = processor.GetMetricByName <long>(metricName, gen2Label);
Assert.NotNull(summary);
Assert.Equal(30, summary.Sum);
}
public void HandleThreadsEvent_RecordsValues()
{
var options = new MetricsObserverOptions();
var stats = new TestOpenTelemetryMetrics();
var factory = stats.Factory;
var processor = stats.Processor;
var observer = new CLRRuntimeObserver(options, stats, null);
var metrics = new CLRRuntimeSource.ThreadMetrics(100, 100, 200, 200);
observer.HandleThreadsEvent(metrics);
factory.CollectAllMetrics();
var metricName = "clr.threadpool.active";
var summary = processor.GetMetricByName <long>(metricName);
Assert.NotNull(summary);
var mean = summary.Sum / summary.Count;
Assert.Equal(100, mean);
Assert.Equal(100, summary.Min);
Assert.Equal(100, summary.Max);
var workerLabel = new Dictionary <string, string>()
{
{ "kind", "worker" }
}.ToList();
summary = processor.GetMetricByName <long>(metricName, workerLabel);
Assert.NotNull(summary);
mean = summary.Sum / summary.Count;
Assert.Equal(100, mean);
Assert.Equal(100, summary.Min);
Assert.Equal(100, summary.Max);
var comportLabel = new Dictionary <string, string>()
{
{ "kind", "completionPort" }
}.ToList();
summary = processor.GetMetricByName <long>(metricName, comportLabel);
Assert.NotNull(summary);
mean = summary.Sum / summary.Count;
Assert.Equal(100, mean);
Assert.Equal(100, summary.Min);
Assert.Equal(100, summary.Max);
metricName = "clr.threadpool.avail";
summary = processor.GetMetricByName <long>(metricName);
Assert.NotNull(summary);
mean = summary.Sum / summary.Count;
Assert.Equal(100, mean);
Assert.Equal(100, summary.Min);
Assert.Equal(100, summary.Max);
summary = processor.GetMetricByName <long>(metricName, workerLabel);
Assert.NotNull(summary);
mean = summary.Sum / summary.Count;
Assert.Equal(100, mean);
Assert.Equal(100, summary.Min);
Assert.Equal(100, summary.Max);
summary = processor.GetMetricByName <long>(metricName, comportLabel);
Assert.NotNull(summary);
mean = summary.Sum / summary.Count;
Assert.Equal(100, mean);
Assert.Equal(100, summary.Min);
Assert.Equal(100, summary.Max);
}
public void HandleHeapEvent_RecordsValues()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new CLRRuntimeObserver(options, stats, tags, null);
CLRRuntimeSource.HeapMetrics metrics = new CLRRuntimeSource.HeapMetrics(1000, new List <long>()
{
10, 20, 30
});
observer.HandleHeapEvent(metrics);
var memUsedViewData = stats.ViewManager.GetView(ViewName.Create("clr.memory.used"));
var aggData = MetricsHelpers.SumWithTags(memUsedViewData) as IMeanData;
Assert.Equal(1000, aggData.Mean);
Assert.Equal(1000, aggData.Max);
Assert.Equal(1000, aggData.Min);
var gcViewData = stats.ViewManager.GetView(ViewName.Create("clr.gc.collections"));
var aggData2 = MetricsHelpers.SumWithTags(gcViewData) as ISumDataLong;
Assert.Equal(60, aggData2.Sum);
aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
{
TagValue.Create("gen0")
}) as ISumDataLong;
Assert.Equal(10, aggData2.Sum);
aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
{
TagValue.Create("gen1")
}) as ISumDataLong;
Assert.Equal(20, aggData2.Sum);
aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
{
TagValue.Create("gen2")
}) as ISumDataLong;
Assert.Equal(30, aggData2.Sum);
metrics = new CLRRuntimeSource.HeapMetrics(5000, new List <long>()
{
15, 25, 30
});
observer.HandleHeapEvent(metrics);
memUsedViewData = stats.ViewManager.GetView(ViewName.Create("clr.memory.used"));
aggData = MetricsHelpers.SumWithTags(memUsedViewData) as IMeanData;
Assert.Equal((5000 + 1000) / 2, aggData.Mean);
Assert.Equal(5000, aggData.Max);
Assert.Equal(1000, aggData.Min);
gcViewData = stats.ViewManager.GetView(ViewName.Create("clr.gc.collections"));
aggData2 = MetricsHelpers.SumWithTags(gcViewData) as ISumDataLong;
Assert.Equal(70, aggData2.Sum);
aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
{
TagValue.Create("gen0")
}) as ISumDataLong;
Assert.Equal(15, aggData2.Sum);
aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
{
TagValue.Create("gen1")
}) as ISumDataLong;
Assert.Equal(25, aggData2.Sum);
aggData2 = MetricsHelpers.SumWithTags(gcViewData, new List <ITagValue>()
{
TagValue.Create("gen2")
}) as ISumDataLong;
Assert.Equal(30, aggData2.Sum);
}
