Exemple #1
0
        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);
        }
Exemple #2
0
        private static MetricsWebHostOptions GetMetricsWebHostOptions(MetricsOptions metricsOptions)
        {
            var options = new MetricsWebHostOptions();

            if (!metricsOptions.Enabled)
            {
                return(options);
            }

            if (!metricsOptions.PrometheusEnabled)
            {
                return(options);
            }

            options.EndpointOptions = endpointOptions =>
            {
                switch (metricsOptions.PrometheusFormatter?.ToLowerInvariant() ?? string.Empty)
                {
                case "protobuf":
                    endpointOptions.MetricsEndpointOutputFormatter =
                        new MetricsPrometheusProtobufOutputFormatter();
                    break;

                default:
                    endpointOptions.MetricsEndpointOutputFormatter =
                        new MetricsPrometheusTextOutputFormatter();
                    break;
                }
            };

            return(options);
        }
        /// <summary>
        /// Переопределяет форматирование метрик роута "/metrics-text" для использования в Prometheus
        /// </summary>
        /// <param name="services"></param>
        /// <param name="configuration"></param>
        private static void ConfigurePrometheusMetrics(IServiceCollection services, IConfiguration configuration)
        {
            var metrics = AppMetrics.CreateDefaultBuilder()
                          .OutputMetrics.AsPrometheusPlainText()
                          .Build();

            services.AddMetrics(metrics);

            var options = new MetricsWebHostOptions();

            options.EndpointOptions = endpointsOptions =>
            {
                endpointsOptions.MetricsTextEndpointOutputFormatter = metrics
                                                                      .OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>()
                                                                      .First();
            };

            services.AddMetricsReportingHostedService(options.UnobservedTaskExceptionHandler);
            services.AddMetricsEndpoints(options.EndpointOptions, configuration);
            services.AddMetricsTrackingMiddleware(options.TrackingMiddlewareOptions, configuration);

            services.AddSingleton <IStartupFilter, DefaultMetricsEndpointsStartupFilter>();
            services.AddMetricsTrackingMiddleware(configuration);
            services.AddSingleton <IStartupFilter, DefaultMetricsTrackingStartupFilter>();
        }
        public static IServiceCollection AddAppMetrics(this IServiceCollection services, AppMetricsOptions appMetricsOptions = null)
        {
            if (appMetricsOptions?.IsEnabled ?? false)
            {
                var metrics = App.Metrics.AppMetrics.CreateDefaultBuilder()
                              .Configuration.Configure(appMetricsOptions.MetricsOptions)
                              .OutputMetrics.AsPrometheusPlainText()
                              .Build();

                var options = new MetricsWebHostOptions
                {
                    EndpointOptions = endpointsOptions =>
                    {
                        endpointsOptions.MetricsEndpointEnabled             = appMetricsOptions.MetricEndpointsOptions.MetricsEndpointEnabled;
                        endpointsOptions.MetricsTextEndpointEnabled         = appMetricsOptions.MetricEndpointsOptions.MetricsTextEndpointEnabled;
                        endpointsOptions.EnvironmentInfoEndpointEnabled     = appMetricsOptions.MetricEndpointsOptions.EnvironmentInfoEndpointEnabled;
                        endpointsOptions.MetricsTextEndpointOutputFormatter = metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First();
                        endpointsOptions.MetricsEndpointOutputFormatter     = metrics.OutputMetricsFormatters.OfType <MetricsPrometheusTextOutputFormatter>().First();
                    },

                    TrackingMiddlewareOptions = trackingMiddlewareOptions =>
                    {
                        trackingMiddlewareOptions.ApdexTrackingEnabled       = appMetricsOptions.MetricsWebTrackingOptions.ApdexTrackingEnabled;
                        trackingMiddlewareOptions.ApdexTSeconds              = appMetricsOptions.MetricsWebTrackingOptions.ApdexTSeconds;
                        trackingMiddlewareOptions.IgnoredHttpStatusCodes     = appMetricsOptions.MetricsWebTrackingOptions.IgnoredHttpStatusCodes;
                        trackingMiddlewareOptions.IgnoredRoutesRegexPatterns = appMetricsOptions.MetricsWebTrackingOptions.IgnoredRoutesRegexPatterns;
                        trackingMiddlewareOptions.OAuth2TrackingEnabled      = appMetricsOptions.MetricsWebTrackingOptions.OAuth2TrackingEnabled;
                    },
                };

                services.AddMetrics(metrics);

                services.AddMetricsReportingHostedService(options.UnobservedTaskExceptionHandler);
                services.AddMetricsEndpoints(options.EndpointOptions);
                services.AddMetricsTrackingMiddleware(options.TrackingMiddlewareOptions);

                services.AddSingleton <IStartupFilter>(new DefaultMetricsEndpointsStartupFilter());
                services.AddSingleton <IStartupFilter>(new DefaultMetricsTrackingStartupFilter());
            }

            return(services);
        }