internal MetricsClockBuilder(
IMetricsBuilder metricsBuilder,
Action <IClock> clock)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
}
/// <summary>
/// Sends all metrics and health checks periodically to an Application Insights instrumentation.
/// </summary>
public static IMetricsBuilder PushToApplicationInsights(this IMetricsBuilder builder,
Action <AppInsightsMetricsReporterOptions> configureAction = null)
{
builder.Services.Configure <HealthCheckPublisherOptions>(options =>
{
options.Predicate = r => !r.Tags.Contains("startup");
options.Delay = TimeSpan.FromSeconds(2);
options.Timeout = TimeSpan.FromSeconds(30);
options.Period = TimeSpan.FromSeconds(30);
});
builder.Services.Configure(configureAction);
builder.Services.AddSingleton <IHealthCheckPublisher>(r => new AppInsightsMetricsPublisher(
r.GetRequiredService <IMetricsRegistry>(),
r.GetRequiredService <TelemetryClient>(),
r.GetRequiredService <IOptionsMonitor <AppInsightsMetricsReporterOptions> >()
));
// The following workaround permits adding an IHealthCheckPublisher
// instance to the service container when one or more other hosted
// services have already been added to the app. This workaround
// won't be required with the release of ASP.NET Core 3.0. For more
// information, see: https://github.com/aspnet/Extensions/issues/639.
builder.Services.TryAddEnumerable(
ServiceDescriptor.Singleton(typeof(IHostedService),
typeof(HealthCheckPublisherOptions).Assembly.GetType(
"Microsoft.Extensions.Diagnostics.HealthChecks.HealthCheckPublisherHostedService")));
return(builder);
}
public static IMetricsBuilder ConfigurePrometheus(CeresOptions options, IMetricsBuilder builder)
{
if (options.Prometheus == null)
{
builder.OutputMetrics.AsPrometheusProtobuf();
builder.OutputMetrics.AsPrometheusPlainText();
return(builder);
}
switch (options.Prometheus.OutputFormat)
{
case "proto":
builder.OutputMetrics.AsPrometheusProtobuf();
break;
case "text":
builder.OutputMetrics.AsPrometheusPlainText();
break;
default:
builder.OutputMetrics.AsPrometheusProtobuf();
builder.OutputMetrics.AsPrometheusPlainText();
break;
}
return(builder);
}
internal MetricsReservoirSamplingBuilder(
IMetricsBuilder metricsBuilder,
Action <DefaultSamplingReservoirProvider> defaultReservoir)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_defaultReservoir = defaultReservoir ?? throw new ArgumentNullException(nameof(defaultReservoir));
}
public static void ConfigureMetrics(IMetricsBuilder builder, MetricsInfluxConfig config, string appName)
{
builder.Report.ToInfluxDb(options =>
{
options.InfluxDb.BaseUri = new Uri(config.Url);
options.InfluxDb.Database = config.Database;
options.InfluxDb.UserName = config.Username;
options.InfluxDb.Password = config.Password;
options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
options.HttpPolicy.FailuresBeforeBackoff = 5;
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
options.Filter = null;
options.FlushInterval = TimeSpan.FromSeconds(20);
});
builder.Configuration.Configure(options =>
{
options.GlobalTags["app"] = appName;
options.Enabled = true;
options.ReportingEnabled = true;
});
var scheduler = new AppMetricsTaskScheduler(
TimeSpan.FromSeconds(3),
async() => { await Task.WhenAll(new MetricsBuilder().Build().ReportRunner.RunAllAsync()); });
scheduler.Start();
}
internal EnvOutputFormattingBuilder(
IMetricsBuilder metricsBuilder,
Action <IEnvOutputFormatter> formatter)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_formatter = formatter ?? throw new ArgumentNullException(nameof(formatter));
}
/// <summary>
/// This method must be called before using metrics, it accepts
/// a full configured <see cref="MetricsBuilder"/> and is used
/// to create an internal version of metrics to help you in
/// creating metrics.
/// </summary>
/// <param name="builder"></param>
public static void InitMetrics(IMetricsBuilder builder)
{
if (Metrics != null)
{
throw new JarvisFrameworkEngineException("Metrics already configured, cannot configure more than once");
}
Metrics = builder.Build();
}
internal MetricsFilterBuilder(
IMetricsBuilder metricsBuilder,
Action <IFilterMetrics> metricsFilter)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_metricsFilter = metricsFilter ?? throw new ArgumentNullException(nameof(metricsFilter));
_filter = new MetricsFilter();
}
public MetricFieldsBuilder(
IMetricsBuilder metricsBuilder,
MetricFields metricFields,
Action <MetricFields> configureAction)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_configureAction = configureAction ?? throw new ArgumentNullException(nameof(configureAction));
_metricFields = metricFields ?? new MetricFields();
}
internal MetricsConfigurationBuilder(
IMetricsBuilder metricsBuilder,
MetricsOptions currentOptions,
Action <MetricsOptions> setupAction)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_setupAction = setupAction ?? throw new ArgumentNullException(nameof(setupAction));
_options = currentOptions ?? new MetricsOptions();
}
internal MetricsReportingBuilder(
IMetricsBuilder metricsBuilder,
MetricsFormatterCollection formatters,
Action <IReportMetrics> reporters)
{
Builder = metricsBuilder ?? throw new ArgumentNullException(nameof(metricsBuilder));
_formatters = formatters ?? throw new ArgumentNullException(nameof(formatters));
_reporters = reporters ?? throw new ArgumentNullException(nameof(reporters));
}
/// <summary>
/// Adds InfluxDB reporting.
/// </summary>
/// <param name="metricsBuilder">IMetricBuilder to add InfluxDB reporting to.</param>
/// <param name="influxDbOptions">Configuration options for InfluxDB reporting.</param>
static void AddInfluxDb(this IMetricsBuilder metricsBuilder, MetricsReportingInfluxDbOptions influxDbOptions)
{
if (influxDbOptions.InfluxDb.BaseUri == null)
{
return;
}
metricsBuilder.Report.ToInfluxDb(influxDbOptions);
}
public static IMetricsRoot BuildAndAddTo(
this IMetricsBuilder builder,
IServiceCollection services)
{
var metrics = builder.Build();
services.AddMetrics(metrics);
return(metrics);
}
public static IMetricsBuilder WithSystemPerforrmanceCounters(this IMetricsBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
Metric.Config.WithSystemCounters();
return(builder);
}
public static IMetricsBuilder AddReporter(this IMetricsBuilder builder,
Action <MetricsReports> reportsAction)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddReporter(reportsAction, Metric.Config);
return(builder);
}
private static void BuildReporting(IMetricsBuilder builder, MetricsReportingOptions options)
{
if (options.ReportConsole)
{
builder.Report.ToConsole();
}
if (!string.IsNullOrWhiteSpace(options.ReportFile))
{
builder.Report.ToTextFile(options.ReportFile);
}
}
private static void ConfigureMetricsBuilder(IMetricsBuilder metricsBuilder, CeresOptions options, ApplicationOptions appOptions)
{
metricsBuilder.Configuration.Configure(a =>
{
a.Enabled = options.Enabled;
a.AddServerTag();
a.AddEnvTag();
a.GlobalTags.Add("app", appOptions.ApplicationName);
a.DefaultContextLabel = appOptions.ApplicationName;
a.ReportingEnabled = options.InfluxDb?.Enabled ?? false;
});
}
public static IMetricsBuilder AddLogReporter(this IMetricsBuilder builder, Action <LogReporterOptions> configureAction)
{
if (configureAction == null)
{
throw new ArgumentNullException(nameof(configureAction));
}
builder.AddLogReporter();
builder.Services.Configure(configureAction);
return(builder);
}
public static IMetricsBuilder RegisterExperiment(this IMetricsBuilder builder, string name, string description,
object[] alternatives = null, params string[] metrics)
{
builder.AddSplitTesting();
builder.Services.AddScoped(r =>
{
var identifier = r.GetRequiredService <ISegmentIdentifier>();
var experiment = new Experiment(identifier, name, description, alternatives, metrics);
return(GetOrAdd(new ExperimentKey(name), experiment));
});
return(builder);
}
public void AddCloudMetricsPublisher(IMetricsBuilder builder, ISafeLogger logger, AzureOptions options)
{
logger.Info(() => "Adding Application Insights Metrics & Health Checks Reporting");
builder.PushToApplicationInsights(p =>
{
p.MetricsSampleEventName = Constants.Events.MetricsSample;
p.HealthCheckEventName = Constants.Events.HealthCheck;
p.PublishHealthChecks = true;
p.PublishHealthy = false;
p.PublishMetrics = true;
});
}
public static IMetricsBuilder AddCloudMetricsPublisher <T>(this IMetricsBuilder builder, ISafeLogger logger,
ICloudOptions options)
where T : ICloudOptions
{
foreach (var module in ScanForTypesImplementing <ICloudMetricsPublisher <T> >())
{
var method =
typeof(ICloudMetricsPublisher <T>).GetMethod(nameof(ICloudMetricsPublisher <T>
.AddCloudMetricsPublisher));
method?.Invoke(module, new object[] { builder, logger, options });
}
return(builder);
}
public static IMetricsBuilder ToInfluxDb(this IMetricsBuilder metricsBuilder, IConfigurationSection configurationSection)
{
#region report to influxdb
if (configurationSection.Exists())
{
var appMetrics_Influxdb_Enable = configurationSection["Enable"];
if (appMetrics_Influxdb_Enable.ToLower() == bool.TrueString.ToLower())
{
metricsBuilder.Report.ToInfluxDb(options =>
{
var appMetrics_influxdb_address = configurationSection["Address"];
var appMetrics_influxdb_database = configurationSection["Database"];
var appMetrics_influxdb_username = configurationSection["UserName"];
var appMetrics_influxdb_password = configurationSection["Password"];
options.InfluxDb = new App.Metrics.Reporting.InfluxDB.InfluxDbOptions()
{
BaseUri = new Uri(appMetrics_influxdb_address),
Database = appMetrics_influxdb_database,
UserName = appMetrics_influxdb_username,
Password = appMetrics_influxdb_password,
CreateDataBaseIfNotExists = true,
};
if (configurationSection.GetSection("Options").Exists())
{
options.HttpPolicy = new App.Metrics.Reporting.InfluxDB.Client.HttpPolicy
{
FailuresBeforeBackoff = int.Parse(configurationSection["Options:FailuresBeforeBackoff"] ?? "3"),
BackoffPeriod = TimeSpan.FromSeconds(int.Parse(configurationSection["Options:BackoffPeriod"] ?? "30")),
Timeout = TimeSpan.FromSeconds(int.Parse(configurationSection["Options:BackoffPeriod"] ?? "15"))
};
options.FlushInterval = TimeSpan.FromSeconds(int.Parse(configurationSection["Options:FlushInterval"] ?? "5"));
}
else
{
options.HttpPolicy = new App.Metrics.Reporting.InfluxDB.Client.HttpPolicy
{
FailuresBeforeBackoff = 3,
BackoffPeriod = TimeSpan.FromSeconds(15),
Timeout = TimeSpan.FromSeconds(15)
};
options.FlushInterval = TimeSpan.FromSeconds(5);
}
});
}
}
#endregion
return(metricsBuilder);
}
/// <summary>
/// Adds HTTP reporting.
/// </summary>
/// <param name="metricsBuilder">IMetricBuilder to add InfluxDB reporting to.</param>
/// <param name="hostEnvironment">Provides information about the hosting environment an application is running in.</param>
/// <param name="httpOptions">Configuration options of HTTP reporting. </param>
static void AddOverHttp(this IMetricsBuilder metricsBuilder, IHostEnvironment hostEnvironment, MetricsReportingHttpOptions httpOptions)
{
if (httpOptions.HttpSettings.RequestUri == null)
{
return;
}
var jobName = hostEnvironment.ApplicationName.Replace('/', '.');
var requestUrl = $"{httpOptions.HttpSettings.RequestUri.AbsoluteUri.TrimEnd('/')}/job/{jobName}";
httpOptions.HttpSettings.RequestUri = new Uri(requestUrl);
httpOptions.MetricsOutputFormatter = new MetricsPrometheusTextOutputFormatter();
metricsBuilder.Report.OverHttp(httpOptions);
}
public static IMetricsBuilder AddReport(this IMetricsBuilder metricsBuilder, IConfigurationSection configurationSection)
{
#region report to influxdb
var appMetrics_Influxdb_Enable = configurationSection["Influxdb:Enable"];
if (appMetrics_Influxdb_Enable.ToLower() == bool.TrueString.ToLower())
{
metricsBuilder.Configuration.Configure(options =>
{
options.AddEnvTag(configurationSection["Environment"]);
options.Enabled = true;
});
metricsBuilder.Report.ToInfluxDb(options =>
{
var appMetrics_influxdb_address = configurationSection["Influxdb:Address"];
var appMetrics_influxdb_database = configurationSection["Influxdb:Database"];
var appMetrics_influxdb_username = configurationSection["Influxdb:UserName"];
var appMetrics_influxdb_password = configurationSection["Influxdb:Password"];
options.HttpPolicy = new App.Metrics.Reporting.InfluxDB.Client.HttpPolicy
{
FailuresBeforeBackoff = 3,
BackoffPeriod = TimeSpan.FromSeconds(30),
Timeout = TimeSpan.FromSeconds(3)
};
options.FlushInterval = TimeSpan.FromSeconds(5);
options.InfluxDb = new App.Metrics.Reporting.InfluxDB.InfluxDbOptions()
{
BaseUri = new Uri(appMetrics_influxdb_address),
Database = appMetrics_influxdb_database,
UserName = appMetrics_influxdb_username,
Password = appMetrics_influxdb_password,
CreateDataBaseIfNotExists = true,
};
});
}
else
{
metricsBuilder.Configuration.Configure(options =>
{
options.Enabled = false;
});
}
#endregion
return(metricsBuilder);
}
private static void SetupOutputs(IMetricsBuilder metricBuilder, Outputs outputs)
{
if (!outputs.Enabled)
{
return;
}
if (outputs.Text.Enabled)
{
metricBuilder.OutputMetrics.AsPlainText();
}
if (outputs.JSON.Enabled)
{
metricBuilder.OutputMetrics.AsJson();
}
}
public static IMetricsBuilder AddMetricsOptions(
this IMetricsBuilder builder,
Action <MetricsOptions> setupAction)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (setupAction == null)
{
throw new ArgumentNullException(nameof(setupAction));
}
builder.Services.Configure <MetricsOptions>(setupAction);
return(builder);
}
/// <summary>
/// Apply configuration conventions
/// </summary>
/// <param name="configurationBuilder"></param>
/// <param name="conventionContext"></param>
/// <returns></returns>
public static IMetricsBuilder ApplyConventions(this IMetricsBuilder configurationBuilder, IConventionContext conventionContext)
{
var configuration = conventionContext.Get <IConfiguration>()
?? throw new ArgumentException("Configuration was not found in context", nameof(conventionContext));
foreach (var item in conventionContext.Conventions.Get <IMetricsConvention, MetricsConvention>())
{
if (item is IMetricsConvention convention)
{
convention.Register(conventionContext, configuration, configurationBuilder);
}
else if (item is MetricsConvention @delegate)
{
@delegate(conventionContext, configuration, configurationBuilder);
}
}
return(configurationBuilder);
}
public static IMetricsBuilder AddHealthChecks(this IMetricsBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var environment = GetServiceFromCollection <IHostingEnvironment>(builder.Services);
if (environment == null)
{
return(builder);
}
HealthChecksAsServices.AddHealthChecksAsServices(builder.Services,
DefaultMetricsAssemblyDiscoveryProvider.DiscoverAssemblies(environment.ApplicationName));
return(builder);
}
private static void Initialize(CLI root)
{
if (root == null)
{
throw new InvalidOperationException("root should not be null.");
}
string context = root.RunTag ?? nameof(EGBench);
IMetricsBuilder builder = AppMetrics.CreateDefaultBuilder()
.Filter.With(new MetricsFilter().WhereContext(context))
.Configuration.Configure(options =>
{
options.DefaultContextLabel = context;
options.GlobalTags.Clear();
options.Enabled = true;
options.ReportingEnabled = true;
});
if (root.AppInsightsKey.HasValue)
{
EGBenchLogger.WriteLine($"Reporting metrics to application insights with instrumentation key={root.AppInsightsKey.Value}");
builder.Report.ToApplicationInsights(root.AppInsightsKey.Value);
}
else
{
isConsole = true;
EGBenchLogger.WriteLine("Reporting metrics to console since --app-insights-key was not specified.");
builder.Report.ToConsole(options =>
{
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
});
}
metricsRoot = builder.Build();
_ = Task.Run(() => ReportingLoop(metricsRoot, root.MetricsIntervalSeconds));
public static IServiceCollection AddMetrics(this IServiceCollection services, IMetricsBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var metrics = builder.Build();
AddCoreServices(services, metrics);
return(services);
}
