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