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); }