Esempio n. 1
0
        public static void InitializeSubscriber(CLI root)
        {
            if (metricsRoot != null)
            {
                return;
            }

            Initialize(root);
            SubscribeE2ELatencyMs = CreateHistogram("Subscribe-E2E Latency (ms)", UnitMs);

            SubscribeEventsSuccess           = CreateCounter("Subscribe-Events", UnitCount, (Status, Success));
            SubscribeRequestsSuccess         = CreateCounter("Subscribe-Requests", UnitCount, (Status, Success));
            SubscribeRequestLatencyMsSuccess = CreateHistogram("Subscribe-Request Latency (ms)", UnitMs, (Status, Success));

            SubscribeEventsUserError           = CreateCounter("Subscribe-Events", UnitCount, (Status, UserError));
            SubscribeRequestsUserError         = CreateCounter("Subscribe-Requests", UnitCount, (Status, UserError));
            SubscribeRequestLatencyMsUserError = CreateHistogram("Subscribe-Request Latency (ms)", UnitMs, (Status, UserError));

            SubscribeEventsSystemError           = CreateCounter("Subscribe-Events", UnitCount, (Status, SystemError));
            SubscribeRequestsSystemError         = CreateCounter("Subscribe-Requests", UnitCount, (Status, SystemError));
            SubscribeRequestLatencyMsSystemError = CreateHistogram("Subscribe-Request Latency (ms)", UnitMs, (Status, SystemError));
        }
Esempio n. 2
0
        public static void InitializePublisher(CLI root)
        {
            if (metricsRoot != null)
            {
                return;
            }

            Initialize(root);
            PublishEventsSuccess           = CreateCounter("Publish-Events", UnitCount, (Status, Success));
            PublishRequestsSuccess         = CreateCounter("Publish-Requests", UnitCount, (Status, Success));
            PublishRequestLatencyMsSuccess = CreateHistogram("Publish-Request Latency (ms)", UnitMs, (Status, Success));

            PublishEventsUserError           = CreateCounter("Publish-Events", UnitCount, (Status, UserError));
            PublishRequestsUserError         = CreateCounter("Publish-Requests", UnitCount, (Status, UserError));
            PublishRequestLatencyMsUserError = CreateHistogram("Publish-Request Latency (ms)", UnitMs, (Status, UserError));

            PublishEventsSystemError           = CreateCounter("Publish-Events", UnitCount, (Status, SystemError));
            PublishRequestsSystemError         = CreateCounter("Publish-Requests", UnitCount, (Status, SystemError));
            PublishRequestLatencyMsSystemError = CreateHistogram("Publish-Request Latency (ms)", UnitMs, (Status, SystemError));

            PublishRequestsFailed = CreateCounter("Publish-Requests", UnitCount, (Status, ClientError));
        }
Esempio n. 3
0
        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));