public void ConfigureServices(IServiceCollection services)
{
services.AddControllers(config =>
{
config.RespectBrowserAcceptHeader = true;
config.ReturnHttpNotAcceptable = true;
}).AddJsonOptions(options =>
{
options.JsonSerializerOptions.Converters.Add(new JsonPrimitiveConverter());
options.JsonSerializerOptions.Converters.Add(new JsonKeyValueConverter());
options.JsonSerializerOptions.Converters.Add(new JsonNodeConverter());
options.JsonSerializerOptions.Converters.Add(new JsonNodeIdConverter());
options.JsonSerializerOptions.Converters.Add(new JsonMapConverter());
})
.AddMvcOptions(c =>
{
c.OutputFormatters.Add(new NodeOutputFormatter());
});
var startIt = new GrpcFileStore(new Config(
1,
log => Console.WriteLine(log),
new DirectoryInfo(Assembly.GetEntryAssembly().Location).Parent,
AppMetrics.CreateDefaultBuilder().Build()));
services.AddSingleton <ISessionProvider>(provider => startIt);
services.AddResponseCompression();
}
public void should_register_metric_fields()
{
var annottated = new Annottated();
ICompositeMetric metrics = AppMetrics.RegisterObject(annottated);
Assert.That(metrics.Metrics.Count, Is.EqualTo(1));
}
public static IWebHostBuilder UseClassifiedAdsMonitoringServices(this IWebHostBuilder hostBuilder)
{
hostBuilder.UseMetrics((context, options) =>
{
var metrics = AppMetrics.CreateDefaultBuilder()
.Configuration.Configure(metricsOptions =>
{
context.Configuration.GetSection("AppMetrics:MetricsOptions").Bind(metricsOptions);
})
.OutputMetrics.AsPrometheusPlainText()
.Build();
options.EndpointOptions = endpointsOptions =>
{
context.Configuration.GetSection("AppMetrics:MetricEndpointsOptions").Bind(endpointsOptions);
endpointsOptions.MetricsTextEndpointOutputFormatter = metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First();
endpointsOptions.MetricsEndpointOutputFormatter = metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First();
};
options.TrackingMiddlewareOptions = trackingMiddlewareOptions =>
{
context.Configuration.GetSection("AppMetrics:MetricsWebTrackingOptions").Bind(trackingMiddlewareOptions);
};
});
return(hostBuilder);
}
static void Main(string[] args)
{
Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.Build();
// Kestrel
var builder = new WebHostBuilder()
.SuppressStatusMessages(true)
.UseKestrel(c => c.AddServerHeader = false)
//.UseEnvironment("Staging")
.ConfigureMetrics(Metrics)
.UseMetrics(
options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsTextEndpointOutputFormatter =
Metrics.OutputMetricsFormatters.GetType <MetricsPrometheusTextOutputFormatter>();
};
})
.UseMetricsWebTracking()
.UseUrls("http://0.0.0.0:5000")
.ConfigureLogging((context, logging) => {
logging.ClearProviders();
logging.AddConsole();
})
.UseStartup <StartUp>();
var host = builder.Build();
host.Run();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddHealthChecks();
services.AddOpenTracing(x =>
{
x.ConfigureAspNetCore(options =>
{
options.Hosting.IgnorePatterns.Add(ctx => ctx.IsHealthCheckEndpoint());
options.Hosting.IgnorePatterns.Add(ctx => ctx.IsMetricsEndpoint());
});
});
services.AddJaeger(Configuration);
Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.Build();
services.AddMetrics(Metrics);
services.AddMetricsEndpoints(x =>
{
x.MetricsEndpointEnabled = false;
x.EnvironmentInfoEndpointEnabled = false;
x.MetricsTextEndpointOutputFormatter =
Metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First();
});
}
/*
* Initializing metrics
*/
#region Methods
private static void InitializeMetrics()
{
//Building the metrics object and setting host and port
Metrics = AppMetrics.CreateDefaultBuilder()
.Report.ToInfluxDb(options =>
{
options.InfluxDb.BaseUri = new Uri("http://127.0.0.1:8086/");
options.InfluxDb.Database = "sample-db";
options.InfluxDb.CreateDataBaseIfNotExists = true;
})
.Configuration.Configure(options =>
{
options.AddServerTag();
})
.Build();
//Start logging metrics
var scheduler = new AppMetricsTaskScheduler(
TimeSpan.FromSeconds(5),
async() =>
{
await Task.WhenAll(Metrics.ReportRunner.RunAllAsync());
});
scheduler.Start();
machineMetricsThread.Start();
}
public static IWebHost BuildWebHost(string[] args)
{
ConfigureLogging();
Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf()
.Build();
return(WebHost.CreateDefaultBuilder(args)
.ConfigureMetrics(Metrics)
.UseMetrics(
options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsTextEndpointOutputFormatter = Metrics.OutputMetricsFormatters.GetType <MetricsPrometheusTextOutputFormatter>();
endpointsOptions.MetricsEndpointOutputFormatter = Metrics.OutputMetricsFormatters.GetType <MetricsPrometheusProtobufOutputFormatter>();
};
})
.UseSerilog()
.UseStartup <Startup>()
.UseUrls("http://localhost:1111")
.Build());
}
public static IWebHost BuildWebHost(string[] args)
{
var metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.Build();
var webhost = WebHost.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((hostingContext, config) =>
{
var env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
})
.ConfigureMetrics(metrics)
.UseMetricsEndpoints(options =>
{
options.MetricsEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
options.MetricsTextEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter();
})
.UseStartup <Startup>()
.UseSerilog()
.Build();
return(webhost);
}
/// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
Action <CacheManager.Core.ConfigurationBuilderCachePart> settings = (x) =>
{
x.WithMicrosoftLogging(log =>
{
log.AddConsole(LogLevel.Debug);
})
.WithDictionaryHandle();
};
services.AddAuthentication()
.AddJwtBearer("DocimaxHerosApi", x =>
{
x.RequireHttpsMetadata = false;
x.Authority = "http://127.0.0.1:50774";
x.Audience = "DocimaxHerosApi";
})
.AddJwtBearer("AccountTransfer", x =>
{
x.RequireHttpsMetadata = false;
x.Authority = "http://127.0.0.1:50774";
x.Audience = "AccountTransfer";
})
.AddJwtBearer("DocimaxHeros", x =>
{
x.RequireHttpsMetadata = false;
x.Authority = "http://127.0.0.1:50774";
x.Audience = "DocimaxHeros";
});
services.AddOcelot()
.AddStoreOcelotConfigurationInConsul()
.AddCacheManager(settings)
.AddOrleansHttpGateway((OrleansRequesterConfiguration config) =>
{
config.MapRouteToGraininterface = (route) =>
{
return("I{GrainName}Grain".Replace("{GrainName}", route.GrainName));
};
config.RequestContextInjection = (context) =>
{
Orleans.Runtime.RequestContext.Set("Client-IP", context.HttpContext.Connection.RemoteIpAddress.ToString());
if (context.HttpContext.Request.Headers.TryGetValue("Authorization", out StringValues value))
{
Orleans.Runtime.RequestContext.Set("Authorization", value);
}
};
})
.AddAdministration("/administration", "secret");
services.AddNanoFabricConsul(Configuration);
var metrics = AppMetrics.CreateDefaultBuilder()
.Build();
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsEndpoints();
services.AddMetricsReportScheduler();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var metrics = AppMetrics.CreateDefaultBuilder()
.Report.ToInfluxDb(options =>
{
options.InfluxDb.BaseUri = new Uri("http://influxdb:8086"); // TODO: read from appSettings
options.InfluxDb.Database = "appmetric";
options.InfluxDb.CreateDataBaseIfNotExists = true;
})
.Report.OverUds(new MetricsReportingSocketOptions()
{
SocketSettings = new SocketSettings()
{
ProtocolType = ProtocolType.IP,
Address = "/var/run/telegraf/telegraf.sock"
},
MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter(new MetricsInfluxDbLineProtocolOptions()),
FlushInterval = TimeSpan.FromSeconds(30)
})
.Build();
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsReportScheduler();
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;
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1).AddMetrics();
}
private static IMetricsRoot ConfigureMetrics(IComponentContext context)
{
return(AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf()
.Build());
}
/// <summary>
/// Configures sending message handlers, tasks, system and GC events metrics
/// over http and into InfluxDb.
/// </summary>
/// <param name="services">IServiceCollection to add the services to.</param>
/// <param name="hostContext">Context containing the common services on the IHost.</param>
/// <returns>The Microsoft.Extensions.DependencyInjection.IServiceCollection so that additional
/// calls can be chained.</returns>
public static IServiceCollection AddConsoleMetrics(this IServiceCollection services, HostBuilderContext hostContext)
{
var metricsBuilder = AppMetrics.CreateDefaultBuilder()
.Configuration.Configure(options =>
{
options.Enabled = true;
options.ReportingEnabled = true;
});
metricsBuilder.OutputMetrics.AsPrometheusPlainText();
var metricsConfig = hostContext.Configuration.GetSection(MicroserviceConstants.MetricsConfiguration.Metrics);
var metricsOptions = new MetricsConfigurationOptions();
metricsConfig.Bind(metricsOptions);
metricsBuilder.AddInfluxDb(metricsOptions.ReportingInfluxDb);
metricsBuilder.AddOverHttp(hostContext.HostingEnvironment, metricsOptions.ReportingOverHttp);
var metrics = metricsBuilder.Build();
services.AddSingleton(metrics.OutputEnvFormatters);
services.AddSingleton <IMetrics>(metrics);
services.AddSingleton(metrics);
services.AddMetricsReporter(metricsOptions);
if (metricsOptions.AddSystemMetrics)
{
services.AddAppMetricsCollectors();
}
return(services);
}
public IMetricsRoot Build(OcelotMetricsConfig ocelotMetricsConfig)
{
var metrics = AppMetrics.CreateDefaultBuilder()
.Configuration
.Configure(options =>
{
options.AddAppTag(ocelotMetricsConfig.App);
options.AddEnvTag(ocelotMetricsConfig.Env);
})
.Report
.ToInfluxDb(options =>
{
var influxDb = options.InfluxDb;
influxDb.BaseUri = new Uri(ocelotMetricsConfig.ConnectionString);
influxDb.Database = ocelotMetricsConfig.DatabaseName;
influxDb.UserName = ocelotMetricsConfig.UserName;
influxDb.Password = ocelotMetricsConfig.Password;
options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
options.HttpPolicy.FailuresBeforeBackoff = 5;
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
options.FlushInterval = TimeSpan.FromSeconds(5);
})
.Build();
return(metrics);
}
public static IServiceCollection AddAppMetrics(this IServiceCollection services)
{
var metricOptions = GetMetricOptions(services);
if (metricOptions.Enabled) // true is enable metrics
{
var metrics = AppMetrics.CreateDefaultBuilder()
.Configuration.Configure(options =>
{
options.GlobalTags.Add("svrenv", metricOptions.ServerEnvironment);
options.GlobalTags.Add("applicationsuite", metricOptions.ApplicationSuite);
})
.Report.ToInfluxDb(options =>
{
options.InfluxDb.BaseUri = new Uri(metricOptions.InfluxDbUrl);
options.InfluxDb.Database = metricOptions.InfluxDbName;
options.InfluxDb.CreateDataBaseIfNotExists = true;
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(metricOptions.HttpPolicyTimeOut);
options.FlushInterval = TimeSpan.FromSeconds(metricOptions.FlushInterval);
})
.Build();
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsReportingHostedService();
services.AddSingleton <IHostedService, MetricsReporter>();
}
return(services);
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args)
{
var metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.Build();
return(WebHost.CreateDefaultBuilder(args)
.UseMetrics(
options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsEndpointOutputFormatter = metrics.OutputMetricsFormatters.GetType <MetricsPrometheusTextOutputFormatter>();
};
})
.ConfigureAppConfiguration((context, builder) =>
{
if (context.HostingEnvironment.EnvironmentName == "Local")
{
return;
}
builder.AddConfigServer(context.HostingEnvironment.EnvironmentName);
})
.UseStartup <Startup>());
}
private static IMetricsRoot BuildAppMetrics(MetricOptions options) {
var metricsBuilder = AppMetrics.CreateDefaultBuilder();
switch (options.Provider) {
case "graphite":
metricsBuilder.Report.ToGraphite(new MetricsReportingGraphiteOptions {
Graphite = {
BaseUri = new Uri(options.Data.GetString("server"))
}
});
break;
case "http":
metricsBuilder.Report.OverHttp(new MetricsReportingHttpOptions {
HttpSettings = {
RequestUri = new Uri(options.Data.GetString("server")),
UserName = options.Data.GetString("username"),
Password = options.Data.GetString("password"),
}
});
break;
case "influxdb":
metricsBuilder.Report.ToInfluxDb(new MetricsReportingInfluxDbOptions {
InfluxDb = {
BaseUri = new Uri(options.Data.GetString("server")),
UserName = options.Data.GetString("username"),
Password = options.Data.GetString("password"),
Database = options.Data.GetString("database", "exceptionless")
}
});
break;
default:
return null;
}
return metricsBuilder.Build();
}
public static IServiceCollection AddDefaultMetrics(this IServiceCollection services,
IConfiguration configuration, string defaultContextLabel)
{
var influxDb = configuration["AppMetrics:InfluxDbServer"];
var influxDatabase = configuration["AppMetrics:InfluxDbDatabase"];
if (!string.IsNullOrWhiteSpace(influxDb))
{
var metrics = AppMetrics.CreateDefaultBuilder()
.Report.ToInfluxDb(influxDb, influxDatabase, TimeSpan.FromSeconds(5))
.Configuration.Configure(o =>
{
o.DefaultContextLabel = defaultContextLabel;
o.AddAppTag("deckhub-web");
o.AddServerTag(Environment.MachineName);
o.Enabled = true;
o.ReportingEnabled = true;
})
.Build();
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware(o =>
{
o.ApdexTSeconds = 0.1;
o.ApdexTrackingEnabled = true;
});
services.AddMetricsReportScheduler();
//services.AddSingleton<IHostedService>(new MetricsReportWriter(metrics, TimeSpan.FromSeconds(5)));
}
return(services);
}
public void Setup()
{
_metrics = AppMetrics.CreateDefaultBuilder().Build();
var random = new Random(123456789);
for (var histogramIndex = 0; histogramIndex < HistogramCount; histogramIndex++)
{
for (var valueIndex = 0; valueIndex < ValueCountInHistogram; valueIndex++)
{
var name = $"test_{histogramIndex}";
var labelKeys = new string[LabelCount];
var labelValues = new string[LabelCount];
for (var labelIndex = 0; labelIndex < LabelCount; labelIndex++)
{
labelKeys[labelIndex] = "key" + labelIndex;
labelValues[labelIndex] = "entitytype:" + random.Next(0, ValuesPerLabel);
}
_metrics.Measure.Histogram.Update(new HistogramOptions {
Name = name
},
new MetricTags(labelKeys, labelValues), random.Next(0, 10000));
}
}
}
private static IHostBuilder createHostBuilderWithPrometheus(string[] args)
{
IMetricsRoot metrics = AppMetrics
.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf()
.Build();
// http://localhost:5000/metrics-text
// http://localhost:5000/metrics
return(Host
.CreateDefaultBuilder(args)
.ConfigureMetrics(metrics)
.UseMetricsWebTracking()
.UseMetrics(options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsTextEndpointOutputFormatter
= metrics.OutputMetricsFormatters.GetType <MetricsPrometheusTextOutputFormatter>();
//endpointsOptions.MetricsEndpointOutputFormatter
// = metrics.OutputMetricsFormatters.GetType<MetricsPrometheusProtobufOutputFormatter>();
};
})
.ConfigureWebHostDefaults(webHostBuilder => webHostBuilder.UseStartup <Startup>()));
}
public static void Main(string[] args)
{
Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
// .OutputMetrics.AsPrometheusProtobuf()
.Build();
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <DbzMySqlContext>();
DbzInitializer.Initialize(context);
}
catch (Exception ex)
{
//var logger = services.GetRequiredService<ILogger<Program>>();
Console.WriteLine("An error occurred while seeding the database.");
Console.WriteLine(ex.Message);
}
}
host.Run();
}
public static IServiceCollection AddAppMetricsToInfluxDb(this IServiceCollection services, IConfiguration configuration)
{
var appMetrics = configuration.GetSection(nameof(ApplicationMetrics)).Get <ApplicationMetrics>();
services.AddMetrics(AppMetrics.CreateDefaultBuilder().Report.ToInfluxDb(options =>
{
options.InfluxDb.BaseUri = new Uri(appMetrics.DataStore.Address);
options.InfluxDb.Database = appMetrics.DataStore.Database;
options.InfluxDb.UserName = appMetrics.DataStore.UserName;
options.InfluxDb.Password = appMetrics.DataStore.Password;
options.InfluxDb.Consistenency = appMetrics.DataStore.Consistenency;
options.InfluxDb.RetentionPolicy = appMetrics.DataStore.RetentionPolicy;
options.InfluxDb.CreateDataBaseIfNotExists = appMetrics.DataStore.CreateDataBaseIfNotExists;
options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(appMetrics.HttpPolicy.BackoffPeriodInSeconds);
options.HttpPolicy.FailuresBeforeBackoff = appMetrics.HttpPolicy.FailuresBeforeBackoff;
options.HttpPolicy.Timeout = TimeSpan.FromSeconds(appMetrics.HttpPolicy.TimeoutInSeconds);
options.MetricsOutputFormatter = new MetricsInfluxDbLineProtocolOutputFormatter();
options.FlushInterval = TimeSpan.FromSeconds(appMetrics.FlushIntervalInSeconds);
}).Build())
.AddMetricsReportingHostedService()
.AddMetricsTrackingMiddleware(options =>
{
options.ApdexTSeconds = appMetrics.Tracking.ApdexTSeconds;
options.IgnoredHttpStatusCodes = appMetrics.Tracking.IgnoredHttpStatusCodes;
});
return(services);
}
static void ConfigureMetrics(HostBuilderContext context, IServiceCollection services)
{
var metricsBuilder = AppMetrics.CreateDefaultBuilder()
.Configuration.Configure(
options =>
{
options.Enabled = true;
options.ReportingEnabled = true;
});
// TODO: Перенести в basic-microservice.
const string metricsSection = MicroserviceConstants.MetricsConfiguration.ConfigSection;
if (!string.IsNullOrEmpty(context.Configuration[$"{metricsSection}:InfluxDb:BaseUri"]))
{
var configuration = context.Configuration.GetSection(metricsSection);
var config = new MetricsReportingInfluxDbOptions();
configuration.Bind(config);
void MetricsConfig(MetricsReportingInfluxDbOptions conf)
{
conf.FlushInterval = config.FlushInterval;
conf.InfluxDb = config.InfluxDb;
}
metricsBuilder.Report.ToInfluxDb(MetricsConfig);
}
services.AddSingleton(metricsBuilder.Build());
}
public static IServiceCollection AddEdamosMetrics(this IServiceCollection services, IConfigurationRoot config)
{
var metrics = AppMetrics.CreateDefaultBuilder();
HttpClient httpClient = new HttpClient();
httpClient.BaseAddress = Consts.InfluxDb.Uri;
httpClient.GetAsync($"query?q=CREATE RETENTION POLICY {Consts.InfluxDb.RetentionPolicy} ON {Consts.InfluxDb.MetricsDbName} DURATION 15m REPLICATION 1 DEFAULT");
metrics.Report.ToInfluxDb(options =>
{
options.FlushInterval = TimeSpan.FromSeconds(5);
options.InfluxDb.BaseUri = Consts.InfluxDb.Uri;
options.InfluxDb.Database = Consts.InfluxDb.MetricsDbName;
});
metrics.Configuration.Configure(
options =>
{
options.Enabled = true;
options.ReportingEnabled = true;
});
services.AddMetrics(metrics);
var hostOptions = new MetricsWebHostOptions();
services.AddMetricsReportScheduler(hostOptions.UnobservedTaskExceptionHandler);
//services.AddMetricsEndpoints(hostOptions.EndpointOptions);
services.AddMetricsTrackingMiddleware(hostOptions.TrackingMiddlewareOptions);
return(services);
}
public void ConfigureServices(IServiceCollection services)
{
services.Configure <KestrelServerOptions>(options => { options.AllowSynchronousIO = true; });
services
.AddControllers()
.AddControllersAsServices()
.AddMetrics();
services.AddHealthChecks()
.AddRedis(Configuration.GetConnectionString("Redis"))
.AddNpgSql(Configuration.GetConnectionString("DocumentStore"), name: "DocumentStore");
services.AddGraphQL(SchemaBuilder.New()
.AddMutationType <ChatMutation>()
.AddQueryType <ChatQuery>()
.AddAllLocalTypes().Create());
var metrics = AppMetrics.CreateDefaultBuilder()
.Configuration.ReadFrom(Configuration)
.OutputMetrics.AsPrometheusPlainText()
.Build();
services.AddMetrics(metrics);
services.AddMetricsEndpoints(endpointsOptions => endpointsOptions.MetricsEndpointOutputFormatter =
endpointsOptions.MetricsOutputFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First());
services.AddMetricsReportingHostedService();
services.AddMetricsTrackingMiddleware(Configuration);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//services.AddMvcCore().AddMetricsCore();
//services.AddMetrics();
var metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics
.AsPrometheusPlainText()
.Build();
metrics.Options.ReportingEnabled = true;
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsReportingHostedService();
services.AddMetricsEndpoints(options =>
options.MetricsEndpointOutputFormatter = metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First());
services.AddMvc();
}
public static IWebHost BuildWebHost(string[] args)
{
Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf()
.Configuration.Configure(opt => {
opt.AddAppTag("app-tag");
opt.AddEnvTag("env-tag");
})
.Build();
return(WebHost.CreateDefaultBuilder(args)
.ConfigureMetrics(Metrics)
.UseMetrics(
options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsTextEndpointOutputFormatter = Metrics.OutputMetricsFormatters.GetType <MetricsPrometheusTextOutputFormatter>();
endpointsOptions.MetricsEndpointOutputFormatter = Metrics.OutputMetricsFormatters.GetType <MetricsPrometheusProtobufOutputFormatter>();
};
})
.UseUrls("http://*:5000")
.UseStartup <Startup>()
.Build());
}
public void should_add_class_tags_to_registered_metric()
{
var annottated = new Annottated();
ICompositeMetric metrics = AppMetrics.RegisterObject(annottated);
Assert.That(HasTag(metrics.Config.Tags, "global-tag-name"), Is.True);
}
public static IServiceCollection AddMetricFromConfiguration(
this IServiceCollection services,
IConfiguration configuration
)
{
var cfg = configuration.GetTypedSection <ApplicationMetric>();
if (cfg is null || cfg.Enabled == false)
{
return(services);
}
var metricBuilder = AppMetrics
.CreateDefaultBuilder()
.Configuration.ReadFrom(configuration);
SetupOutputs(metricBuilder, cfg.Outputs);
SetupReports(metricBuilder, cfg.Reports);
var metricsRoot = metricBuilder.Build();
services.AddMetrics(metricsRoot);
SetupTracking(services, cfg.Tracking);
SetupEndpoints(services, cfg.Endpoints);
services.AddMetricsReportingHostedService();
return(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
Action <ConfigurationBuilderCachePart> settings = (x) =>
{
x.WithMicrosoftLogging(log =>
{
log.AddConsole(LogLevel.Debug);
})
.WithDictionaryHandle();
};
services.AddAuthentication()
.AddJwtBearer("TestKey", x =>
{
x.Authority = "test";
x.Audience = "test";
});
services.AddOcelot(Configuration);
var metrics = AppMetrics.CreateDefaultBuilder()
.Build();
services.AddMetrics(metrics);
services.AddMetricsTrackingMiddleware();
services.AddMetricsEndpoints();
services.AddMetricsReportScheduler();
}
public static IWebHost BuildWebHost(string[] args)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build();
Metrics = AppMetrics.CreateDefaultBuilder()
.OutputMetrics.AsPrometheusPlainText()
.OutputMetrics.AsPrometheusProtobuf()
.Configuration.ReadFrom(configuration)
.Build();
return(WebHost.CreateDefaultBuilder(args)
.ConfigureMetrics(Metrics)
.UseMetrics(
options =>
{
options.EndpointOptions = endpointsOptions =>
{
endpointsOptions.MetricsTextEndpointOutputFormatter = new MetricsPrometheusTextOutputFormatter(new MetricsPrometheusOptions());
endpointsOptions.MetricsEndpointOutputFormatter = new MetricsPrometheusProtobufOutputFormatter(new MetricsPrometheusOptions());
};
})
.UseMetricsWebTracking()
.UseStartup <Startup>()
.UseUrls("http://localhost:10010/")
.Build());
}
