public static IWebHostBuilder CreateWebHostBuilder(string[] args)
{
return(WebHost
.CreateDefaultBuilder(args)
.UseKestrel()
.UseIISIntegration()
.ConfigureMetricsWithDefaults(
builder =>
{
var filter = new MetricsFilter()
.WhereType(
MetricType.Apdex,
MetricType.Counter,
MetricType.Gauge,
MetricType.Histogram,
MetricType.Meter,
MetricType.Timer
);
builder.Report.ToConsole(
options =>
{
options.MetricsOutputFormatter = new MetricsJsonOutputFormatter();
options.FlushInterval = TimeSpan.FromSeconds(2);
});
builder.Report.ToTextFile(
options =>
{
options.MetricsOutputFormatter = new MetricsJsonOutputFormatter();
options.AppendMetricsToTextFile = true;
options.Filter = filter;
options.FlushInterval = TimeSpan.FromSeconds(20);
options.OutputPathAndFileName = @".\Reports\Metrics.txt";
});
builder.Report.ToInfluxDb(InfluxDbOptions);
})
.ConfigureHealthWithDefaults(
builder =>
{
builder
.HealthChecks.AddCheck("DatabaseConnected", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy("Database Connection OK")))
.HealthChecks.AddProcessPrivateMemorySizeCheck("Private Memory Size", 200)
.HealthChecks.AddProcessVirtualMemorySizeCheck("Virtual Memory Size", 200)
.HealthChecks.AddProcessPhysicalMemoryCheck("Working Set", 200)
.HealthChecks.AddPingCheck("Network", "google.com", TimeSpan.FromSeconds(10));
})
.UseHealth()
.UseMetricsWebTracking()
.UseMetrics()
.UseStartup <Startup>()
.UseSerilog(
(hostingContext, loggerConfiguration) =>
{
loggerConfiguration
.ReadFrom.Configuration(hostingContext.Configuration);
}
));
}
/// <summary>
/// Create HTTP endpoint where metrics will be available in various formats:
/// GET / => visualization application
/// GET /json => metrics serialized as JSON
/// GET /text => metrics in human readable text format
/// </summary>
/// <param name="httpUriPrefix">prefix where to start HTTP endpoint</param>
/// <param name="filter">Only report metrics that match the filter.</param>
/// <param name="maxRetries">maximum number of attempts to start the http listener. Note the retry time between attempts is dependent on this value</param>
/// <returns>Chain-able configuration object.</returns>
public MetricsConfig WithHttpEndpoint(string httpUriPrefix, MetricsFilter filter = null, int maxRetries = 3)
{
if (this.isDisabled)
{
return(this);
}
return(WithHttpEndpoint(httpUriPrefix, _ => { }, filter, maxRetries));
}
internal MetricsRecordBuilderImpl(MetricsCollector parent, MetricsInfo info, MetricsFilter
rf, MetricsFilter mf, bool acceptable)
{
this.parent = parent;
timestamp = Time.Now();
recInfo = info;
metrics = Lists.NewArrayList();
tags = Lists.NewArrayList();
recordFilter = rf;
metricFilter = mf;
this.acceptable = acceptable;
}
public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var isService = true;
if (Debugger.IsAttached || args.Contains("--console"))
{
Log.Information("Setting isService to true");
isService = false;
}
var pathToContentRoot = Directory.GetCurrentDirectory();
if (isService)
{
var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
pathToContentRoot = Path.GetDirectoryName(pathToExe);
}
var filter = new MetricsFilter();
filter.WhereContext(c => c == MetricsRegistry.RabbitMqContext);
var webHostArgs = args.Where(arg => arg != "--console").ToArray();
var host = WebHost.CreateDefaultBuilder(webHostArgs)
.ConfigureServices(services => services.AddAutofac())
.UseContentRoot(pathToContentRoot)
.UseMetrics(options => {
options.EndpointOptions = endpointOptions => {
endpointOptions.MetricsEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
};
})
.UseStartup <Startup>()
.UseSerilog()
.Build();
if (isService)
{
Log.Information("Running as a service");
host.RunAsService();
}
else
{
Log.Information("Running as a console app");
host.Run();
}
}
public void Can_use_reporter_of_type_and_use_specific_metrics_filter()
{
// Arrange
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var builder = new MetricsBuilder().Report.Using <TestReporter>(filter: filter);
// Act
var metrics = builder.Build();
var reporter = (metrics.Reporters as MetricsReporterCollection)?.GetType <TestReporter>();
// Assert
reporter?.Filter.Should().BeSameAs(filter);
}
/// <inheritdoc />
public MetricsContextValueSource GetForContext(string context)
{
Logger.Trace("Getting metrics snaphot for {MetricsContext}", context);
var data = Get();
var filter = new MetricsFilter().WhereContext(context);
var contextData = data.Filter(filter);
Logger.Trace("Getting metrics snaphot found {MetricsContextCount}", contextData.Contexts?.Count());
return(contextData.Contexts?.FirstOrDefault() ?? MetricsContextValueSource.Empty);
}
public MetricsData Filter(MetricsFilter filter)
{
if (!filter.IsMatch(this.Context))
{
return(MetricsData.Empty);
}
return(new MetricsData(this.Context,
this.Gauges.Where(g => filter.IsMatch(g)),
this.Counters.Where(c => filter.IsMatch(c)),
this.Meters.Where(m => filter.IsMatch(m)),
this.Histograms.Where(h => filter.IsMatch(h)),
this.Timers.Where(t => filter.IsMatch(t)),
this.ChildMetrics.Select(m => m.Filter(filter))));
}
public void Can_filter_metrics_by_name_using_predicate()
{
var filter = new MetricsFilter().WhereName(name => name == "test_gauge");
var currentData = _metrics.Snapshot.Get(filter);
var context = currentData.Contexts.Single();
var gaugeValue = context.Gauges.FirstOrDefault();
gaugeValue.Should().NotBeNull();
Assert.Null(context.Counters.FirstOrDefault());
Assert.Null(context.Meters.FirstOrDefault());
Assert.Null(context.Histograms.FirstOrDefault());
Assert.Null(context.Timers.FirstOrDefault());
}
private static IMetrics CreateMetrics()
{
var filter = new MetricsFilter().WhereType(MetricType.Timer);
var metrics = new MetricsBuilder()
.OutputMetrics.Using <MetricsFormatter>()
.Report.ToConsole(
options => {
options.FlushInterval = TimeSpan.FromSeconds(30);
options.Filter = filter;
options.MetricsOutputFormatter = new MetricsFormatter();
})
.Build();
return(metrics);
}
public void Can_filter_metrics_by_histograms()
{
var filter = new MetricsFilter().WhereType(MetricType.Histogram);
var currentData = _metrics.Snapshot.Get(filter);
var context = currentData.Contexts.Single();
var histogramValue = context.Histograms.Single();
histogramValue.Name.Should().Be("test_histogram");
histogramValue.Value.LastValue.Should().Be(5);
Assert.Null(context.Counters.FirstOrDefault());
Assert.Null(context.Gauges.FirstOrDefault());
Assert.Null(context.Timers.FirstOrDefault());
Assert.Null(context.Meters.FirstOrDefault());
}
public void Can_filter_metrics_by_tags_keys()
{
var filter = new MetricsFilter().WhereTaggedWithKey("tag1", "tag2");
var currentData = _metrics.Snapshot.Get(filter);
var context = currentData.Contexts.Single();
var counterValue = context.Counters.Single();
var meterValue = context.Meters.Single();
counterValue.Tags.Keys.Should().Contain("tag1");
meterValue.Tags.Keys.Should().Contain("tag2");
Assert.Null(context.Gauges.FirstOrDefault());
Assert.Null(context.Histograms.FirstOrDefault());
Assert.Null(context.Timers.FirstOrDefault());
}
internal MetricsSourceAdapter(string prefix, string name, string description, MetricsSource
source, IEnumerable <MetricsTag> injectedTags, MetricsFilter recordFilter, MetricsFilter
metricFilter, int jmxCacheTTL, bool startMBeans)
{
this.prefix = Preconditions.CheckNotNull(prefix, "prefix");
this.name = Preconditions.CheckNotNull(name, "name");
this.source = Preconditions.CheckNotNull(source, "source");
attrCache = Maps.NewHashMap();
infoBuilder = new MBeanInfoBuilder(name, description);
this.injectedTags = injectedTags;
this.recordFilter = recordFilter;
this.metricFilter = metricFilter;
this.jmxCacheTTL = Contracts.CheckArg(jmxCacheTTL, jmxCacheTTL > 0, "jmxCacheTTL"
);
this.startMBeans = startMBeans;
}
public static IWebHost BuildWebHost(string[] args)
{
var filter = new MetricsFilter();
filter.WhereContext(c => c == MetricsRegistry.Context);
return(WebHost.CreateDefaultBuilder(args)
.ConfigureMetricsWithDefaults(builder =>
{
builder.Filter.With(filter);
builder.Report.ToInfluxDb("http://127.0.0.1:8086", "appmetricsreservoirs");
})
.UseMetrics()
.UseStartup <Startup>()
.Build());
}
public MetricsData Filter(MetricsFilter filter)
{
if (!filter.IsMatch(this.Context))
{
return(MetricsData.Empty);
}
return(new MetricsData(this.Context, this.Timestamp,
this.Environment,
this.Gauges.Where(filter.IsMatch),
this.Counters.Where(filter.IsMatch),
this.Meters.Where(filter.IsMatch),
this.Histograms.Where(filter.IsMatch),
this.Timers.Where(filter.IsMatch),
this.ChildMetrics.Select(m => m.Filter(filter))));
}
public void Can_use_reporter_instance_and_use_specific_metrics_filter_and_flushinterval_and_formatter()
{
// Arrange
var formatter = new MetricsJsonOutputFormatter();
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var builder = new MetricsBuilder().Report.Using <TestReporter>(formatter: formatter, filter: filter, flushInterval: TimeSpan.FromDays(1));
// Act
var metrics = builder.Build();
var reporter = (metrics.Reporters as MetricsReporterCollection)?.GetType <TestReporter>();
// Assert
reporter?.Filter.Should().BeSameAs(filter);
reporter?.FlushInterval.Should().Be(TimeSpan.FromDays(1));
reporter?.Formatter.Should().BeOfType(typeof(MetricsJsonOutputFormatter));
}
public void Can_filter_metrics_by_context()
{
var filter = new MetricsFilter().WhereContext("test_context1");
var currentData = _metrics.Snapshot.Get(filter);
var context = currentData.Contexts.Single();
var counterValue = context.Counters.Single();
counterValue.Name.Should().Be("test_counter|tag1:value");
counterValue.Value.Count.Should().Be(1);
Assert.Null(context.Meters.FirstOrDefault());
Assert.Null(context.Gauges.FirstOrDefault());
Assert.Null(context.Histograms.FirstOrDefault());
Assert.Null(context.Timers.FirstOrDefault());
}
public MetricsData Filter(MetricsFilter filter)
{
if (!filter.IsMatch(this.Context))
{
return MetricsData.Empty;
}
return new MetricsData(this.Context, this.Timestamp,
this.Environment,
this.Gauges.Where(filter.IsMatch),
this.Counters.Where(filter.IsMatch),
this.Meters.Where(filter.IsMatch),
this.Histograms.Where(filter.IsMatch),
this.Timers.Where(filter.IsMatch),
this.ChildMetrics.Select(m => m.Filter(filter)));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var filter = new MetricsFilter().WhereType(MetricType.Timer);
var metrics = new MetricsBuilder()
.Configuration.Configure(
options =>
{
options.WithGlobalTags((globalTags, info) =>
{
globalTags.Add("app", "metricssample");
globalTags.Add("env", "Development");
globalTags.Add("server", Environment.MachineName);
});
options.ReportingEnabled = true;
options.Enabled = true;
})
.Report.ToInfluxDb(
options =>
{
options.InfluxDb.BaseUri = new Uri("http://WIN-IR190QMVTJ6:8086");
options.InfluxDb.CreateDataBaseIfNotExists = true;
options.InfluxDb.Database = "netcoredb";
//options.InfluxDb.UserName = "******";
//options.InfluxDb.Password = "******";
//options.InfluxDb.Consistenency = "consistency";
//options.InfluxDb.RetentionPolicy = retentionpolicy
options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
options.HttpPolicy.FailuresBeforeBackoff = 5;
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
options.Filter = filter;
options.FlushInterval = TimeSpan.FromSeconds(20);
})
.Build();
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsReportingHostedService();
services.AddMvcCore().AddMetricsCore();
services.AddControllersWithViews();
services.Configure <IISServerOptions>(options =>
{
options.AllowSynchronousIO = true;
});
}
public void Can_set_textfile_reporter_metrics_filter()
{
// Arrange
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var builder = new MetricsBuilder().Report.ToTextFile(
options =>
{
options.OutputPathAndFileName = @".\metrics.txt";
options.Filter = filter;
});
// Act
var metrics = builder.Build();
// Assert
metrics.Reporters.First().Filter.Should().BeSameAs(filter);
}
public void Can_filter_metrics_by_name_starting_with()
{
var filter = new MetricsFilter().WhereNameStartsWith("test_");
var currentData = _metrics.Snapshot.Get(filter);
var context = currentData.Contexts.Single();
var counterValue = context.Counters.FirstOrDefault();
var gaugeValue = context.Gauges.FirstOrDefault();
var meterValue = context.Meters.FirstOrDefault();
var histogramValue = context.Histograms.FirstOrDefault();
var timerValue = context.Timers.FirstOrDefault();
counterValue.Should().NotBeNull();
gaugeValue.Should().NotBeNull();
meterValue.Should().NotBeNull();
histogramValue.Should().NotBeNull();
timerValue.Should().NotBeNull();
}
public void Can_set_http_reporter_metrics_filter()
{
// Arrange
var uri = "http://localhost/metrics";
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var builder = new MetricsBuilder().Report.OverHttp(
options =>
{
options.HttpSettings.RequestUri = new Uri(uri);
options.Filter = filter;
});
// Act
var metrics = builder.Build();
// Assert
metrics.Reporters.First().Filter.Should().BeSameAs(filter);
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
var Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf()
.Build();
var filter = new MetricsFilter().WhereType(App.Metrics.MetricType.Timer);
var metrics = new MetricsBuilder()
.Report.ToInfluxDb(
options => {
options.InfluxDb.BaseUri = new Uri("http://127.0.0.1:8086");
options.InfluxDb.Database = "defaultdb";
options.InfluxDb.Consistenency = "admin";
options.InfluxDb.UserName = "******";
options.InfluxDb.Password = "******";
options.InfluxDb.RetentionPolicy = "rp";
options.InfluxDb.CreateDataBaseIfNotExists = true;
options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
options.HttpPolicy.FailuresBeforeBackoff = 5;
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
options.Filter = filter;
options.FlushInterval = TimeSpan.FromSeconds(20);
})
.Build();
return(Host.CreateDefaultBuilder(args)
.ConfigureMetrics(Metrics)
.UseMetrics(
options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsTextEndpointOutputFormatter = Metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First();
endpointsOptions.MetricsEndpointOutputFormatter = Metrics.OutputMetricsFormatters.OfType <MetricsPrometheusProtobufOutputFormatter>().First();
};
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
}));
}
// pluginLoader.close(); // jdk7 is saner
internal virtual MetricsFilter GetFilter(string prefix)
{
// don't create filter instances without out options
Org.Apache.Hadoop.Metrics2.Impl.MetricsConfig conf = ((Org.Apache.Hadoop.Metrics2.Impl.MetricsConfig
)Subset(prefix));
if (conf.IsEmpty())
{
return(null);
}
MetricsFilter filter = GetPlugin(prefix);
if (filter != null)
{
return(filter);
}
// glob filter is assumed if pattern is specified but class is not.
filter = new GlobFilter();
filter.Init(conf);
return(filter);
}
/// <summary>
/// Create HTTP endpoint where metrics will be available in various formats:
/// GET / => visualization application
/// GET /json => metrics serialized as JSON
/// GET /text => metrics in human readable text format
/// </summary>
/// <param name="httpUriPrefix">prefix where to start HTTP endpoint</param>
/// <param name="filter">Only report metrics that match the filter.</param>
/// <param name="maxRetries">maximum number of attempts to start the http listener. Note the retry time between attempts is dependent on this value</param>
/// <returns>Chain-able configuration object.</returns>
public MetricsConfig WithHttpEndpoint(string httpUriPrefix, MetricsFilter filter = null, int maxRetries = 3)
{
if (this.isDisabled)
{
return(this);
}
if (this.httpEndpoints.ContainsKey(httpUriPrefix))
{
log.WarnFormat("Http uri prefix {0} already registered. Ignoring...", httpUriPrefix);
return(this);
}
var endpoint = MetricsHttpListener.StartHttpListenerAsync(httpUriPrefix, this.context.DataProvider.WithFilter(filter),
this.healthStatus, this.httpEndpointCancellation.Token, maxRetries);
this.httpEndpoints.Add(httpUriPrefix, endpoint);
return(this);
}
private static void ShouldAcceptImpl(bool expectAcceptList, SubsetConfiguration conf
, IList <MetricsTag> tags, bool[] expectedAcceptedSpec)
{
MetricsFilter globFilter = NewGlobFilter(conf);
MetricsFilter regexFilter = NewRegexFilter(conf);
// Test acceptance of the tag list:
Assert.Equal("accepts " + tags, expectAcceptList, globFilter.Accepts
(tags));
Assert.Equal("accepts " + tags, expectAcceptList, regexFilter.
Accepts(tags));
// Test results on each of the individual tags:
int acceptedCount = 0;
for (int i = 0; i < tags.Count; i++)
{
MetricsTag tag = tags[i];
bool actGlob = globFilter.Accepts(tag);
bool actRegex = regexFilter.Accepts(tag);
Assert.Equal("accepts " + tag, expectedAcceptedSpec[i], actGlob
);
// Both the filters should give the same result:
Assert.Equal(actGlob, actRegex);
if (actGlob)
{
acceptedCount++;
}
}
if (expectAcceptList)
{
// At least one individual tag should be accepted:
Assert.True("No tag of the following accepted: " + tags, acceptedCount
> 0);
}
else
{
// At least one individual tag should be rejected:
Assert.True("No tag of the following rejected: " + tags, acceptedCount
< tags.Count);
}
}
public async Task Can_flush_metrics_to_console_with_options()
{
// Arrange
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var formatter = new TestMetricsFormatter();
var interval = TimeSpan.FromDays(1);
var options = new MetricsReportingConsoleOptions
{
Filter = filter,
MetricsOutputFormatter = formatter,
FlushInterval = interval
};
var reporter = new ConsoleMetricsReporter(options);
var snapshot = new MetricsDataValueSource(DateTime.Now, Enumerable.Empty <MetricsContextValueSource>());
// Act
var result = await reporter.FlushAsync(snapshot, CancellationToken.None);
// Assert
result.Should().BeTrue();
}
public void Can_use_console_reporter_with_setup_action_to_override_defaults()
{
// Arrange
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var builder = new MetricsBuilder().Report.ToConsole(
options =>
{
options.MetricsOutputFormatter = new TestMetricsFormatter();
options.Filter = filter;
options.FlushInterval = TimeSpan.FromDays(1);
});
// Act
var metrics = builder.Build();
// Assert
metrics.Reporters.Should().Contain(reportMetrics => reportMetrics is ConsoleMetricsReporter);
metrics.Reporters.First().FlushInterval.Should().Be(TimeSpan.FromDays(1));
metrics.Reporters.First().Filter.Should().BeSameAs(filter);
metrics.Reporters.First().Formatter.Should().BeOfType <TestMetricsFormatter>();
}
private Result[] CalculateMetrics(Indicator[] indicators)
{
MetricsFilter metricsFilter = new MetricsFilter();
Metric[] metrics = metricsFilter.FilterMetrics();
string[] temp;
List <Result> results = new List <Result>();
float sum;
int count;
List <Indicator> neededIndicators;
foreach (Metric metric in metrics)
{
neededIndicators = new List <Indicator>();
sum = 0;
count = 0;
temp = metric.Metrics.Split(' ');
foreach (string t in temp)
{
neededIndicators.AddRange(indicators.Where(x => x.Code.StartsWith(t)));
}
if (neededIndicators.Count == 0)
{
continue;
}
foreach (Indicator indicator in neededIndicators)
{
sum += indicator.Value;
++count;
}
if (count == 0)
{
count = 1;
}
results.Add(new Result(metric, 3, sum / count));
}
return(results.ToArray());
}
public async Task Can_flush_metrics_via_sockets_with_options()
{
// Arrange
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var formatter = new TestMetricsFormatter();
var interval = TimeSpan.FromDays(1);
var settings = new SocketSettings(defaultProtocol, defaultAddress, defaultPort);
var options = new MetricsReportingSocketOptions
{
Filter = filter,
FlushInterval = interval,
MetricsOutputFormatter = formatter,
SocketSettings = settings
};
var reporter = new SocketMetricsReporter(options);
var snapshot = new MetricsDataValueSource(DateTime.Now, Enumerable.Empty <MetricsContextValueSource>());
// Act
var result = await reporter.FlushAsync(snapshot, CancellationToken.None);
// Assert
result.Should().BeTrue();
}
public void Can_use_udp_socket_reporter_with_options()
{
// Arrange
var filter = new MetricsFilter().WhereType(MetricType.Apdex);
var flushInterval = TimeSpan.FromDays(1);
var settings = new SocketSettings(defaultProtocol, defaultAddress, defaultPort);
var options = new MetricsReportingSocketOptions();
options.Filter = filter;
options.FlushInterval = flushInterval;
options.MetricsOutputFormatter = new TestMetricsFormatter();
options.SocketSettings = settings;
var builder = new MetricsBuilder().Report.OverUdp(options);
// Act
var metrics = builder.Build();
// Assert
metrics.Reporters.Should().Contain(reportMetrics => reportMetrics is SocketMetricsReporter);
metrics.Reporters.First().FlushInterval.Should().Be(flushInterval);
metrics.Reporters.First().Filter.Should().BeSameAs(filter);
metrics.Reporters.First().Formatter.Should().BeOfType <TestMetricsFormatter>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
string mackerelApiKey = Configuration.GetValue <string>("Mackerel:ApiKey");
string mackerelHostId = Configuration.GetValue <string>("Mackerel:HostId");
var filter = new MetricsFilter();
var metrics = AppMetrics.CreateDefaultBuilder()
.Report.ToMackerel(
options =>
{
options.ApiKey = mackerelApiKey;
options.HostId = mackerelHostId;
options.HttpOptions.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
options.HttpOptions.HttpPolicy.FailuresBeforeBackoff = 3;
options.HttpOptions.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
options.HttpOptions.Filter = filter;
options.HttpOptions.FlushInterval = TimeSpan.FromSeconds(60);
})
.Build();
SampleMetricsRunner.ScheduleSomeSampleMetrics(metrics);
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsReportingHostedService();
services.AddMetricsEndpoints();
services.AddMvc()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
.AddMetrics();
}
public FilteredMetrics(MetricsDataProvider provider, MetricsFilter filter)
{
this.provider = provider;
this.filter = filter;
}
public static MetricsDataProvider WithFilter(this MetricsDataProvider provider, MetricsFilter filter)
{
return new FilteredMetrics(provider, filter);
}
