public static IReportFactory AddTextFile(this IReportFactory factory, IMetricsFilter filter = null)
{
var settings = new TextFileReporterSettings();
factory.AddTextFile(settings, filter);
return(factory);
}
public MetricsDataValueSource GetData(IMetricsFilter filter)
{
_logger.RetrievedMetricsData();
if (_contexts.Count == 0)
{
return(MetricsDataValueSource.Empty);
}
var environment = _environmentInfoProvider.Build();
var contexts = _contexts.Values.Select(g => new MetricsContextValueSource(
g.Context,
g.DataProvider.Gauges.ToArray(),
g.DataProvider.Counters.ToArray(),
g.DataProvider.Meters.ToArray(),
g.DataProvider.Histograms.ToArray(),
g.DataProvider.Timers.ToArray(),
g.DataProvider.ApdexScores.ToArray()
));
var data = new MetricsDataValueSource(_clock.UtcDateTime, environment, contexts);
_logger.GettingMetricsData();
return(data.Filter(filter));
}
public MetricsDataValueSource Filter(IMetricsFilter filter)
{
var contexts = Contexts.FilterBy(filter).WhereNotEmpty();
var environment = filter.ReportEnvironment ? Environment : EnvironmentInfo.Empty;
return(new MetricsDataValueSource(Timestamp, environment, contexts));
}
public static IReportFactory AddInfluxDb(this IReportFactory factory, IMetricsFilter filter = null)
{
var settings = new InfluxDbReporterSettings();
factory.AddInfluxDb(settings, filter);
return(factory);
}
internal async Task Generate(IMetricReporter reporter,
IMetrics metrics,
IMetricsFilter reporterMetricsFilter,
CancellationToken token)
{
if (reporterMetricsFilter == default(IMetricsFilter))
{
reporterMetricsFilter = metrics.Advanced.GlobalFilter;
}
reporter.StartReport(metrics);
var data = await metrics.Advanced.Data.ReadDataAsync(reporterMetricsFilter);
if (data.Environment.Entries.Any() && reporterMetricsFilter.ReportEnvironment)
{
reporter.StartMetricTypeReport(typeof(EnvironmentInfo));
reporter.ReportEnvironment(data.Environment);
reporter.EndMetricTypeReport(typeof(EnvironmentInfo));
}
foreach (var contextValueSource in data.Contexts)
{
ReportMetricType(reporter, contextValueSource.Counters,
c => { reporter.ReportMetric($"{contextValueSource.Context}", c); }, token);
ReportMetricType(reporter, contextValueSource.Gauges,
g => { reporter.ReportMetric($"{contextValueSource.Context}", g); }, token);
ReportMetricType(reporter, contextValueSource.Histograms,
h => { reporter.ReportMetric($"{contextValueSource.Context}", h); }, token);
ReportMetricType(reporter, contextValueSource.Meters,
m => { reporter.ReportMetric($"{contextValueSource.Context}", m); }, token);
ReportMetricType(reporter, contextValueSource.Timers,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); }, token);
}
if (reporterMetricsFilter.ReportHealthChecks)
{
var healthStatus = await metrics.Advanced.Health.ReadStatusAsync();
reporter.StartMetricTypeReport(typeof(HealthStatus));
var passed = healthStatus.Results.Where(r => r.Check.Status.IsHealthy());
var failed = healthStatus.Results.Where(r => r.Check.Status.IsUnhealthy());
var degraded = healthStatus.Results.Where(r => r.Check.Status.IsDegraded());
reporter.ReportHealth(passed, degraded, failed);
reporter.EndMetricTypeReport(typeof(HealthStatus));
}
reporter.EndReport(metrics);
}
public InfluxDbReporterProvider(IInfluxDbReporterSettings settings, IMetricsFilter fitler)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
_settings = settings;
Filter = fitler;
}
public ConsoleReporterProvider(ConsoleReporterSettings settings, IMetricsFilter filter)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
_settings = settings;
Filter = filter;
}
protected void SetupServices(IServiceCollection services,
AppMetricsOptions appMetricsOptions,
AspNetMetricsOptions aspNetMetricsOptions,
IMetricsFilter filter = null, IEnumerable <HealthCheckResult> healthChecks = null)
{
services
.AddLogging()
.AddRouting(options => { options.LowercaseUrls = true; });
services.AddMvc(options => options.AddMetricsResourceFilter());
var builder = services
.AddMetrics(options =>
{
options.DefaultContextLabel = appMetricsOptions.DefaultContextLabel;
options.MetricsEnabled = appMetricsOptions.MetricsEnabled;
options.DefaultSamplingType = appMetricsOptions.DefaultSamplingType;
})
.AddJsonSerialization()
.AddClockType <TestClock>()
.AddHealthChecks(factory =>
{
var checks = healthChecks != null
? healthChecks.ToList()
: new List <HealthCheckResult>();
for (var i = 0; i < checks.Count; i++)
{
var check = checks[i];
factory.Register("Check" + i, () => Task.FromResult(check));
}
})
.AddMetricsMiddleware(options =>
{
options.MetricsTextEndpointEnabled = aspNetMetricsOptions.MetricsTextEndpointEnabled;
options.HealthEndpointEnabled = aspNetMetricsOptions.HealthEndpointEnabled;
options.MetricsEndpointEnabled = aspNetMetricsOptions.MetricsEndpointEnabled;
options.PingEndpointEnabled = aspNetMetricsOptions.PingEndpointEnabled;
options.OAuth2TrackingEnabled = aspNetMetricsOptions.OAuth2TrackingEnabled;
options.HealthEndpoint = aspNetMetricsOptions.HealthEndpoint;
options.MetricsEndpoint = aspNetMetricsOptions.MetricsEndpoint;
options.MetricsTextEndpoint = aspNetMetricsOptions.MetricsTextEndpoint;
options.PingEndpoint = aspNetMetricsOptions.PingEndpoint;
options.IgnoredRoutesRegexPatterns = aspNetMetricsOptions.IgnoredRoutesRegexPatterns;
});
if (filter != null)
{
builder.AddGlobalFilter(filter);
}
}
public static IReportFactory AddInfluxDb(this IReportFactory factory,
string database, Uri baseAddress,
IMetricsFilter filter = null)
{
var settings = new InfluxDBReporterSettings
{
InfluxDbSettings = new InfluxDBSettings(database, baseAddress)
};
factory.AddInfluxDb(settings, filter);
return(factory);
}
public MetricsContextValueSource Filter(IMetricsFilter filter)
{
if (!filter.IsMatch(Context))
{
return(Empty);
}
return(new MetricsContextValueSource(Context,
Gauges.Where(filter.IsMatch),
Counters.Where(filter.IsMatch),
Meters.Where(filter.IsMatch),
Histograms.Where(filter.IsMatch),
Timers.Where(filter.IsMatch)));
}
public DefaultAdvancedMetrics(
ILogger <DefaultAdvancedMetrics> logger,
AppMetricsOptions options,
IClock clock,
IMetricsFilter globalFilter,
IMetricsRegistry registry,
IHealthCheckFactory healthCheckFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
GlobalFilter = globalFilter ?? new DefaultMetricsFilter();
Clock = clock;
_logger = logger;
_registry = registry;
_healthCheckFactory = healthCheckFactory;
}
public async Task <bool> GenerateAsync(IMetricReporter reporter,
IMetrics metrics,
IMetricsFilter reporterMetricsFilter,
CancellationToken token)
{
var startTimestamp = _logger.IsEnabled(LogLevel.Information) ? Stopwatch.GetTimestamp() : 0;
_logger.ReportedStarted(reporter);
if (reporterMetricsFilter == default(IMetricsFilter))
{
reporterMetricsFilter = metrics.Advanced.GlobalFilter;
}
reporter.StartReportRun(metrics);
var data = metrics.Advanced.Data.ReadData(reporterMetricsFilter);
if (data.Environment.Entries.Any() && reporterMetricsFilter.ReportEnvironment)
{
reporter.ReportEnvironment(data.Environment);
}
if (reporterMetricsFilter.ReportHealthChecks)
{
var healthStatus = await metrics.Advanced.Health.ReadStatusAsync(token);
var passed = healthStatus.Results.Where(r => r.Check.Status.IsHealthy()).ToArray();
var failed = healthStatus.Results.Where(r => r.Check.Status.IsUnhealthy()).ToArray();
var degraded = healthStatus.Results.Where(r => r.Check.Status.IsDegraded()).ToArray();
reporter.ReportHealth(metrics.Advanced.GlobalTags, passed, degraded, failed);
foreach (var check in passed)
{
metrics.Increment(ApplicationHealthMetricRegistry.HealthyCheckCounter, check.Name);
}
foreach (var check in degraded)
{
metrics.Increment(ApplicationHealthMetricRegistry.DegradedCheckCounter, check.Name);
}
foreach (var check in failed)
{
metrics.Increment(ApplicationHealthMetricRegistry.UnhealthyCheckCounter, check.Name);
}
}
foreach (var contextValueSource in data.Contexts)
{
ReportMetricType(contextValueSource.Counters,
c => { reporter.ReportMetric($"{contextValueSource.Context}", c); }, token);
ReportMetricType(contextValueSource.Gauges,
g => { reporter.ReportMetric($"{contextValueSource.Context}", g); }, token);
ReportMetricType(contextValueSource.Histograms,
h => { reporter.ReportMetric($"{contextValueSource.Context}", h); }, token);
ReportMetricType(contextValueSource.Meters,
m => { reporter.ReportMetric($"{contextValueSource.Context}", m); }, token);
ReportMetricType(contextValueSource.Timers,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); }, token);
ReportMetricType(contextValueSource.ApdexScores,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); }, token);
}
var result = await reporter.EndAndFlushReportRunAsync(metrics);
_logger.ReportRan(reporter, startTimestamp);
return(result);
}
public MetricsDataValueSource GetData(IMetricsFilter filter)
{
return MetricsDataValueSource.Empty;
}
public MetricsDataValueSource ReadData(IMetricsFilter overrideGlobalFilter)
{
return(_registry.GetData(overrideGlobalFilter));
}
public static IReportFactory AddInfluxDb(this IReportFactory factory,
IInfluxDbReporterSettings settings, IMetricsFilter filter = null)
{
factory.AddProvider(new InfluxDbReporterProvider(settings, filter));
return(factory);
}
public Task <MetricsDataValueSource> GetDataAsync(IMetricsFilter filter)
{
return(AppMetricsTaskCache.EmptyMetricsDataTask);
}
public static IEnumerable <MetricsContextValueSource> FilterBy(this IEnumerable <MetricsContextValueSource> valueSources, IMetricsFilter filter)
{
return(valueSources.Select(g => g.Filter(filter)));
}
public static IMetricsHostBuilder AddGlobalFilter(this IMetricsHostBuilder builder, IMetricsFilter filter)
{
builder.Services.Replace(ServiceDescriptor.Singleton(filter));
return(builder);
}
public Task <MetricsDataValueSource> ReadDataAsync(IMetricsFilter overrideGlobalFilter)
{
return(_registry.GetDataAsync(overrideGlobalFilter));
}
public static IReportFactory AddTextFile(this IReportFactory factory,
ITextFileReporterSettings settings, IMetricsFilter filter = null)
{
factory.AddProvider(new TextFileReporterProvider(settings, filter));
return(factory);
}
