public static IWebHostBuilder UseAppMetrics(this IWebHostBuilder webHostBuilder)
{
return(webHostBuilder
.ConfigureMetricsWithDefaults((context, builder) =>
{
var metricsOptions = new MetricsOptions();
context.Configuration.GetSection("Metrics").Bind(metricsOptions);
if (!metricsOptions.Enabled)
{
return;
}
builder.Report.ToInfluxDb(o =>
{
o.InfluxDb.Database = metricsOptions.Database;
o.InfluxDb.BaseUri = new Uri(metricsOptions.InfluxUrl);
o.InfluxDb.CreateDataBaseIfNotExists = true;
o.FlushInterval = TimeSpan.FromSeconds(metricsOptions.Interval);
});
})
.UseHealth()
.UseHealthEndpoints()
.UseMetricsWebTracking()
.UseMetrics());
}
public static IWebHostBuilder UseMonitoring(this IWebHostBuilder builder, bool enabled)
{
builder
.ConfigureMetricsWithDefaults(bld =>
{
bld.Configuration.Configure(
options =>
{
options.Enabled = enabled;
options.ReportingEnabled = true;
});
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("INFLUXDB")))
{
bld.Report.ToInfluxDb(options =>
{
options.InfluxDb.BaseUri = new Uri(Environment.GetEnvironmentVariable("INFLUXDB"));
options.InfluxDb.Database = "fluentdispatch";
options.FlushInterval = TimeSpan.FromSeconds(5);
options.InfluxDb.CreateDataBaseIfNotExists = true;
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
});
}
});
builder.UseMetricsWebTracking();
builder.UseMetrics <MetricsStartup>();
return(builder);
}
public static IWebHostBuilder UseMetrics(this IWebHostBuilder hostBuilder, string metricsConfigurationKey)
{
hostBuilder.ConfigureMetricsWithDefaults((hostingContext, builder) =>
{
builder.AddReport(hostingContext.Configuration.GetSection(metricsConfigurationKey));
});
hostBuilder.UseMetricsWebTracking();
hostBuilder.UseMetrics();
return(hostBuilder);
}
public static void ConfigureMetrics(IWebHostBuilder webBuilder)
{
webBuilder.ConfigureMetricsWithDefaults((context, builder) =>
{
builder.Configuration.ReadFrom(context.Configuration);
builder.Report.ToInfluxDb(options =>
{
options.FlushInterval = TimeSpan.FromSeconds(5);
context.Configuration.GetSection("MetricsOptions").Bind(options);
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
});
});
webBuilder.UseMetrics();
}
public static IWebHostBuilder ConfigureMetricsWithDefaults(this IWebHostBuilder hostBuilder, Action <IMetricsBuilder> configureMetrics)
{
if (_metricsBuilt)
{
throw new InvalidOperationException("MetricsBuilder allows creation only of a single instance of IMetrics");
}
hostBuilder.ConfigureMetricsWithDefaults(
(context, builder) =>
{
configureMetrics(builder);
});
return(hostBuilder);
}
public static IWebHostBuilder UseMonitoring(this IWebHostBuilder builder, IMonitoringComponent monitoringComponent)
{
builder
.ConfigureMetricsWithDefaults((context, bld) =>
{
bld.Configuration.Configure(
options =>
{
options.Enabled = true;
options.ReportingEnabled = true;
});
monitoringComponent.UseMonitoring(bld.Report);
});
builder.UseMetricsWebTracking();
builder.UseMetrics <MetricsStartup>();
return(builder);
}
public static IWebHostBuilder UseAppMetrics(this IWebHostBuilder webHostBuilder)
=> webHostBuilder.ConfigureMetricsWithDefaults((context, builder) =>
{
var options = context.Configuration.GetOptions <MetricsOptions>("metrics");
if (!options.Enabled)
{
return;
}
if (options.InfluxEnabled)
{
builder.Report.ToInfluxDb(o =>
{
o.InfluxDb.Database = options.Database;
o.InfluxDb.BaseUri = new Uri(options.InfluxUrl);
o.InfluxDb.CreateDataBaseIfNotExists = true;
o.FlushInterval = TimeSpan.FromSeconds(options.Interval);
});
}
if (options.PrometheusEnabled)
{
builder
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf();
}
}
)
.UseHealth()
.UseHealthEndpoints()
.UseMetricsWebTracking()
.UseMetricsEndpoints((context, setup) =>
{
var options = context.Configuration.GetOptions <MetricsOptions>("metrics");
if (options.PrometheusEnabled)
{
setup.MetricsTextEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
setup.MetricsEndpointOutputFormatter = new MetricsPrometheusProtobufOutputFormatter();
}
})
.UseMetrics();
public static IWebHostBuilder AddAppMetrics(this IWebHostBuilder builder, string serviceName)
{
Requires.NotNullOrWhiteSpace(serviceName, nameof(serviceName));
builder.ConfigureMetricsWithDefaults(metricsBuilder => {
metricsBuilder.Configuration.Configure(metricOptions => {
metricOptions.GlobalTags.Add("service-name", serviceName);
});
// Filter out internal App.Metrics library metrics
metricsBuilder.Filter.With(new MetricsFilter().WhereContext(context => context != "appmetrics.internal"));
metricsBuilder.SampleWith.Reservoir(() => new ForwardDecayingLowWeightThresholdReservoir(
sampleSize: 100,
alpha: 0.1, // Bias heavily towards lasst 15 seconds of sampling; disregard everything older than 40 seconds
sampleWeightThreshold: 0.001, // Samples with weight of less than 10% of average should be discarded when rescaling
clock: new App.Metrics.Infrastructure.StopwatchClock(),
rescaleScheduler: new FixedPeriodReservoirRescaleScheduler(TimeSpan.FromSeconds(30))
));
metricsBuilder.Report.ToInfluxDb(Endpoint, "dbname_unused", TimeSpan.FromSeconds(10));
// DEBUG metricsBuilder.Report.ToConsole(TimeSpan.FromSeconds(10));
})
.UseMetrics <MinimalRequestTracking>(webHostMetricOptions => {
webHostMetricOptions.EndpointOptions = (endpointOptions) => {
endpointOptions.EnvironmentInfoEndpointEnabled = false;
endpointOptions.MetricsEndpointEnabled = false;
endpointOptions.MetricsTextEndpointEnabled = true;
};
webHostMetricOptions.TrackingMiddlewareOptions = (trackingOptions) => {
trackingOptions.ApdexTrackingEnabled = false;
// trackingOptions.ApdexTSeconds = 1.0;
trackingOptions.IgnoredHttpStatusCodes.Add((int)HttpStatusCode.NotFound);
trackingOptions.OAuth2TrackingEnabled = false;
};
});
return(builder);
}
public static IWebHostBuilder UseStandardMetrics(this IWebHostBuilder webHostBuilder)
{
return(webHostBuilder
.ConfigureMetricsWithDefaults((webHostBuilderContext, metricsBuilder) =>
{
var influxDb = webHostBuilderContext.Configuration["AppMetrics:InfluxDbServer"];
if (!string.IsNullOrWhiteSpace(influxDb))
{
var influxDatabase = webHostBuilderContext.Configuration["AppMetrics:InfluxDbDatabase"];
if (!string.IsNullOrWhiteSpace(influxDatabase))
{
Console.WriteLine($"Report To {influxDb}/{influxDatabase}");
metricsBuilder.Report.ToInfluxDb(o =>
{
o.InfluxDb.BaseUri = new Uri(influxDb);
o.InfluxDb.Database = influxDatabase;
o.FlushInterval = TimeSpan.FromSeconds(5);
o.InfluxDb.CreateDataBaseIfNotExists = true;
});
}
}
})
.UseMetrics());
}
internal static IWebHostBuilder ConfigureMetric(this IWebHostBuilder @this) => @this
.ConfigureMetricsWithDefaults(builder =>
{
builder.OutputMetrics.AsPrometheusPlainText();
builder.OutputMetrics.AsPrometheusProtobuf();
})
.UseMetricsEndpoints(options =>
{
options.MetricsTextEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
options.MetricsEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
})
.UseMetricsWebTracking();