private async Task ReportHealth(IMetricReporter reporter, IMetrics metrics, CancellationToken token)
{
var healthStatus = await metrics.Health.ReadStatusAsync(token);
var passed = healthStatus.Results.Where(r => r.Check.Status.IsHealthy()).ToArray();
var failed = healthStatus.Results.Where(r => r.Check.Status.IsUnhealthy()).ToArray();
var degraded = healthStatus.Results.Where(r => r.Check.Status.IsDegraded()).ToArray();
reporter.ReportHealth(_options.GlobalTags, passed, degraded, failed);
foreach (var check in passed)
{
metrics.Measure.Counter.Increment(ApplicationHealthMetricRegistry.HealthyCheckCounter, check.Name);
}
foreach (var check in degraded)
{
metrics.Measure.Counter.Increment(ApplicationHealthMetricRegistry.DegradedCheckCounter, check.Name);
}
foreach (var check in failed)
{
metrics.Measure.Counter.Increment(ApplicationHealthMetricRegistry.UnhealthyCheckCounter, check.Name);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageCreateEventController" /> class.
/// </summary>
/// <param name="tracingService">Service for doing traces.</param>
/// <param name="userService">Service to manage users with.</param>
/// <param name="emitter">Emitter to emit messages to.</param>
/// <param name="discordUserClient">Client used to send User API requests to Discord.</param>
/// <param name="discordChannelClient">Client used to send Channel API requests to Discord.</param>
/// <param name="strings">Localizer service for retrieving strings.</param>
/// <param name="adapterOptions">Options to use for the adapter.</param>
/// <param name="commandsService">Client for interacting with the commands service.</param>
/// <param name="gateway">Gateway that discord sends events through.</param>
/// <param name="reporter">Reporter to report metrics to.</param>
/// <param name="logger">Logger used to log information to some destination(s).</param>
public MessageCreateEventController(
ITracingService tracingService,
IUserService userService,
IMessageEmitter emitter,
IDiscordUserClient discordUserClient,
IDiscordChannelClient discordChannelClient,
IStringLocalizer <Strings> strings,
IOptions <AdapterOptions> adapterOptions,
IBrighidCommandsService commandsService,
IGatewayService gateway,
IMetricReporter reporter,
ILogger <MessageCreateEventController> logger
)
{
this.tracingService = tracingService;
this.userService = userService;
this.emitter = emitter;
this.discordUserClient = discordUserClient;
this.discordChannelClient = discordChannelClient;
this.strings = strings;
this.adapterOptions = adapterOptions.Value;
this.commandsService = commandsService;
this.gateway = gateway;
this.reporter = reporter;
this.logger = logger;
}
private static void ReportMetricTypes(IMetricReporter reporter, CancellationToken token, MetricsDataValueSource data)
{
foreach (var contextValueSource in data.Contexts)
{
ReportMetricType(
contextValueSource.Counters,
c => { reporter.ReportMetric($"{contextValueSource.Context}", c); },
token);
ReportMetricType(
contextValueSource.Gauges,
g => { reporter.ReportMetric($"{contextValueSource.Context}", g); },
token);
ReportMetricType(
contextValueSource.Histograms,
h => { reporter.ReportMetric($"{contextValueSource.Context}", h); },
token);
ReportMetricType(
contextValueSource.Meters,
m => { reporter.ReportMetric($"{contextValueSource.Context}", m); },
token);
ReportMetricType(
contextValueSource.Timers,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); },
token);
ReportMetricType(
contextValueSource.ApdexScores,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); },
token);
}
}
public Task <bool> GenerateAsync(
IMetricReporter reporter,
IMetrics metrics,
CancellationToken token)
{
return(GenerateAsync(reporter, metrics, metrics.GlobalFilter, token));
}
internal async Task Generate(IMetricReporter reporter,
IMetrics metrics,
IMetricsFilter reporterMetricsFilter,
CancellationToken token)
{
if (reporterMetricsFilter == default(IMetricsFilter))
{
reporterMetricsFilter = metrics.Advanced.GlobalFilter;
}
reporter.StartReport(metrics);
var data = await metrics.Advanced.Data.ReadDataAsync(reporterMetricsFilter);
if (data.Environment.Entries.Any() && reporterMetricsFilter.ReportEnvironment)
{
reporter.StartMetricTypeReport(typeof(EnvironmentInfo));
reporter.ReportEnvironment(data.Environment);
reporter.EndMetricTypeReport(typeof(EnvironmentInfo));
}
foreach (var contextValueSource in data.Contexts)
{
ReportMetricType(reporter, contextValueSource.Counters,
c => { reporter.ReportMetric($"{contextValueSource.Context}", c); }, token);
ReportMetricType(reporter, contextValueSource.Gauges,
g => { reporter.ReportMetric($"{contextValueSource.Context}", g); }, token);
ReportMetricType(reporter, contextValueSource.Histograms,
h => { reporter.ReportMetric($"{contextValueSource.Context}", h); }, token);
ReportMetricType(reporter, contextValueSource.Meters,
m => { reporter.ReportMetric($"{contextValueSource.Context}", m); }, token);
ReportMetricType(reporter, contextValueSource.Timers,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); }, token);
}
if (reporterMetricsFilter.ReportHealthChecks)
{
var healthStatus = await metrics.Advanced.Health.ReadStatusAsync();
reporter.StartMetricTypeReport(typeof(HealthStatus));
var passed = healthStatus.Results.Where(r => r.Check.Status.IsHealthy());
var failed = healthStatus.Results.Where(r => r.Check.Status.IsUnhealthy());
var degraded = healthStatus.Results.Where(r => r.Check.Status.IsDegraded());
reporter.ReportHealth(passed, degraded, failed);
reporter.EndMetricTypeReport(typeof(HealthStatus));
}
reporter.EndReport(metrics);
}
public static void ReportedStarted(this ILogger logger, IMetricReporter reporter)
{
if (!logger.IsEnabled(LogLevel.Trace))
{
return;
}
ReportStartedAction(logger, reporter.GetType().FullName, null);
}
public async Task ShouldReportMessageCreateEventMetric(
[Frozen, Substitute] IMetricReporter reporter,
[Target] MessageCreateEventController controller
)
{
var cancellationToken = new CancellationToken(false);
await controller.Handle(new MessageCreateEvent { }, cancellationToken);
await reporter.Received().Report(Is(default(MessageCreateEventMetric)), Is(cancellationToken));
}
private async Task ReportHealth(IMetricReporter reporter, IMetrics metrics, CancellationToken token)
{
var healthStatus = await metrics.Health.ReadStatusAsync(token);
var passed = healthStatus.Results.Where(r => r.Check.Status.IsHealthy()).ToArray();
var failed = healthStatus.Results.Where(r => r.Check.Status.IsUnhealthy()).ToArray();
var degraded = healthStatus.Results.Where(r => r.Check.Status.IsDegraded()).ToArray();
reporter.ReportHealth(_options.GlobalTags, passed, degraded, failed);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResumedEventController" /> class.
/// </summary>
/// <param name="gateway">The gateway service to use.</param>
/// <param name="reporter">Reporter used to report metric.</param>
/// <param name="logger">Logger used to log information to some destination(s).</param>
public ResumedEventController(
IGatewayService gateway,
IMetricReporter reporter,
ILogger <ResumedEventController> logger
)
{
this.gateway = gateway;
this.reporter = reporter;
this.logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultGatewayRestartService" /> class.
/// </summary>
/// <param name="utilsFactory">Factory used to create various utilities.</param>
/// <param name="reporter">Reporter used to report metrics.</param>
/// <param name="logger">Logger used to log info to some destination(s).</param>
public DefaultGatewayRestartService(
IGatewayUtilsFactory utilsFactory,
IMetricReporter reporter,
ILogger <DefaultGatewayRestartService> logger
)
{
this.utilsFactory = utilsFactory;
this.reporter = reporter;
this.logger = logger;
}
private Recorder(ILogger logger, ICrashReporter crasher, IAuditReporter auditor, IMetricReporter measurer)
{
logger.GuardAgainstNull(nameof(logger));
crasher.GuardAgainstNull(nameof(crasher));
auditor.GuardAgainstNull(nameof(auditor));
measurer.GuardAgainstNull(nameof(measurer));
this.logger = logger;
this.crasher = crasher;
this.auditor = auditor;
this.measurer = measurer;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReconnectEventController" /> class.
/// </summary>
/// <param name="gateway">The gateway service to use.</param>
/// <param name="utilsFactory">Factory to create utilities with.</param>
/// <param name="reporter">Reporter used to report metrics.</param>
/// <param name="logger">Logger used to log information to some destination(s).</param>
public ReconnectEventController(
IGatewayService gateway,
IGatewayUtilsFactory utilsFactory,
IMetricReporter reporter,
ILogger <ReconnectEventController> logger
)
{
this.gateway = gateway;
this.utilsFactory = utilsFactory;
this.logger = logger;
this.reporter = reporter;
}
public DeduplicationManager(
ISearchProvider searchProvider,
IMetricReporter metricReporter,
IDuplicatesRuleManager duplicatesRuleManager,
IDeduplicationSearchQueryBuilder deduplicationSearchQueryBuilder,
IFindSimilarRecordsRequestBuilder findSimilarRecordsRequestBuilder)
{
_searchProvider = searchProvider;
_metricReporter = metricReporter;
_duplicatesRuleManager = duplicatesRuleManager;
_deduplicationSearchQueryBuilder = deduplicationSearchQueryBuilder;
_findSimilarRecordsRequestBuilder = findSimilarRecordsRequestBuilder;
}
public async Task ShouldReportAReconnectMetric(
bool resumable,
[Frozen, Substitute] IMetricReporter reporter,
[Target] InvalidSessionEventController controller
)
{
var cancellationToken = new CancellationToken(false);
var @event = new InvalidSessionEvent(resumable);
await controller.Handle(@event, cancellationToken);
await reporter.Received().Report(Is(default(InvalidSessionEventMetric)), Is(cancellationToken));
}
public async Task ShouldReportAReconnectMetric(
string sessionId,
[Frozen, Substitute] IMetricReporter reporter,
[Target] ReconnectEventController controller
)
{
var cancellationToken = new CancellationToken(false);
var @event = new ReconnectEvent {
};
await controller.Handle(@event, cancellationToken);
await reporter.Received().Report(Is(default(ReconnectEventMetric)), Is(cancellationToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="HelloEventController" /> class.
/// </summary>
/// <param name="gateway">The gateway service to use.</param>
/// <param name="reporter">Reporter to use to report metrics with.</param>
/// <param name="adapterOptions">Options used across the adapter.</param>
/// <param name="gatewayOptions">The options to use for the gateway.</param>
/// <param name="logger">Logger used to log information to some destination(s).</param>
public HelloEventController(
IGatewayService gateway,
IMetricReporter reporter,
IOptions <AdapterOptions> adapterOptions,
IOptions <GatewayOptions> gatewayOptions,
ILogger <HelloEventController> logger
)
{
this.gateway = gateway;
this.reporter = reporter;
this.adapterOptions = adapterOptions.Value;
this.gatewayOptions = gatewayOptions.Value;
this.logger = logger;
}
public async Task ShouldReportARestartMetric(
string sessionId,
[Frozen, Substitute] IMetricReporter reporter,
[Frozen, Substitute] IGatewayService gateway,
[Target] DefaultGatewayRestartService service
)
{
var cancellationToken = new CancellationToken(false);
var resume = true;
await service.Restart(gateway, resume, cancellationToken);
await reporter.Received().Report(Is(default(GatewayRestartMetric)), Is(cancellationToken));
}
public SystemController(Bootstrap bootstrap)
{
this.bootstrap = bootstrap;
switch (bootstrap.GetVariableSet("environment"))
{
case "aws":
metricReporter = new AWSCloudWatchReporter();
HostingManager = new AWSHostingManager();
break;
default:
metricReporter = new DefaultReporter();
HostingManager = new LocalHostingManager();
break;
}
}
public static void ReportRan(this ILogger logger, IMetricReporter reporter, long startTimestamp)
{
if (!logger.IsEnabled(LogLevel.Information))
{
return;
}
if (startTimestamp == 0)
{
return;
}
var currentTimestamp = Stopwatch.GetTimestamp();
var elapsed = new TimeSpan((long)(TimestampToTicks * (currentTimestamp - startTimestamp)));
_reportRan(logger, reporter.GetType().FullName, elapsed.TotalMilliseconds, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRequestInvoker" /> class.
/// </summary>
/// <param name="client">Client used to send/recieve http messages.</param>
/// <param name="urlBuilder">Builder used to build URLs from requests.</param>
/// <param name="relay">Service used to relay messages back and forth between SQS.</param>
/// <param name="bucketService">Service used to manage buckets.</param>
/// <param name="bucketRepository">Repository to manage buckets.</param>
/// <param name="reporter">Service used to report metrics.</param>
/// <param name="logger">Logger used to log info to some destination(s).</param>
public DefaultRequestInvoker(
HttpMessageInvoker client,
IUrlBuilder urlBuilder,
IRequestMessageRelay relay,
IBucketService bucketService,
IBucketRepository bucketRepository,
IMetricReporter reporter,
ILogger <DefaultRequestInvoker> logger
)
{
this.client = client;
this.urlBuilder = urlBuilder;
this.relay = relay;
this.bucketService = bucketService;
this.bucketRepository = bucketRepository;
this.reporter = reporter;
this.logger = logger;
}
public WorkerRabbitMQ(IConnection conexaoRabbit,
IServiceScopeFactory serviceScopeFactory,
IMetricReporter metricReporter,
ServicoTelemetria servicoTelemetria,
ConsumoDeFilasOptions consumoDeFilasOptions,
ConfiguracaoRabbitOptions configuracaoRabbitOptions,
TelemetriaOptions telemetriaOptions,
IMediator mediator)
{
this.conexaoRabbit = conexaoRabbit ?? throw new ArgumentNullException(nameof(conexaoRabbit));
this.serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
this.telemetriaOptions = telemetriaOptions ?? throw new ArgumentNullException(nameof(telemetriaOptions));
this.mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
this.metricReporter = metricReporter;
this.servicoTelemetria = servicoTelemetria ?? throw new ArgumentNullException(nameof(servicoTelemetria));
this.consumoDeFilasOptions = consumoDeFilasOptions ?? throw new ArgumentNullException(nameof(consumoDeFilasOptions));
this.configuracaoRabbitOptions = configuracaoRabbitOptions ?? throw new ArgumentNullException(nameof(configuracaoRabbitOptions));
comandos = new Dictionary <string, ComandoRabbit>();
RegistrarUseCases();
}
private static void ReportMetricType <T>(IMetricReporter reporter, IEnumerable <T> metrics, Action <T> report, CancellationToken token)
{
var reportingMetrics = metrics.ToList();
if (token.IsCancellationRequested || !reportingMetrics.Any())
{
return;
}
reporter.StartMetricTypeReport(typeof(T));
foreach (var metric in reportingMetrics)
{
if (token.IsCancellationRequested)
{
break;
}
report(metric);
}
reporter.EndMetricTypeReport(typeof(T));
}
public async Task <bool> GenerateAsync(
IMetricReporter reporter,
IMetrics metrics,
IFilterMetrics reporterMetricsFilter,
CancellationToken token)
{
var startTimestamp = _logger.IsEnabled(LogLevel.Trace) ? Stopwatch.GetTimestamp() : 0;
_logger.ReportedStarted(reporter);
if (reporterMetricsFilter == default(IFilterMetrics))
{
reporterMetricsFilter = metrics.GlobalFilter;
}
reporter.StartReportRun(metrics);
var data = metrics.Snapshot.Get(reporterMetricsFilter);
if (data.Environment.Entries.Any() && reporterMetricsFilter.ReportEnvironment)
{
reporter.ReportEnvironment(data.Environment);
}
if (reporterMetricsFilter.ReportHealthChecks)
{
await ReportHealth(reporter, metrics, token);
}
ReportMetricTypes(reporter, token, data);
var result = await reporter.EndAndFlushReportRunAsync(metrics);
_logger.ReportRan(reporter, startTimestamp);
return(result);
}
public static void ReportRunning(this ILogger logger, IMetricReporter reporter)
{
logger.LogTrace(AppMetricsEventIds.Reports.Schedule, $"Running {reporter.GetType()}");
}
public static MetricSpace AddReporter(this MetricSpace target, IMetricReporter reporter)
{
target.Options.Reporters.AddReporter(reporter);
return(target);
}
public async Task <bool> GenerateAsync(IMetricReporter reporter,
IMetrics metrics,
IMetricsFilter reporterMetricsFilter,
CancellationToken token)
{
var startTimestamp = _logger.IsEnabled(LogLevel.Information) ? Stopwatch.GetTimestamp() : 0;
_logger.ReportedStarted(reporter);
if (reporterMetricsFilter == default(IMetricsFilter))
{
reporterMetricsFilter = metrics.Advanced.GlobalFilter;
}
reporter.StartReportRun(metrics);
var data = metrics.Advanced.Data.ReadData(reporterMetricsFilter);
if (data.Environment.Entries.Any() && reporterMetricsFilter.ReportEnvironment)
{
reporter.ReportEnvironment(data.Environment);
}
if (reporterMetricsFilter.ReportHealthChecks)
{
var healthStatus = await metrics.Advanced.Health.ReadStatusAsync(token);
var passed = healthStatus.Results.Where(r => r.Check.Status.IsHealthy()).ToArray();
var failed = healthStatus.Results.Where(r => r.Check.Status.IsUnhealthy()).ToArray();
var degraded = healthStatus.Results.Where(r => r.Check.Status.IsDegraded()).ToArray();
reporter.ReportHealth(metrics.Advanced.GlobalTags, passed, degraded, failed);
foreach (var check in passed)
{
metrics.Increment(ApplicationHealthMetricRegistry.HealthyCheckCounter, check.Name);
}
foreach (var check in degraded)
{
metrics.Increment(ApplicationHealthMetricRegistry.DegradedCheckCounter, check.Name);
}
foreach (var check in failed)
{
metrics.Increment(ApplicationHealthMetricRegistry.UnhealthyCheckCounter, check.Name);
}
}
foreach (var contextValueSource in data.Contexts)
{
ReportMetricType(contextValueSource.Counters,
c => { reporter.ReportMetric($"{contextValueSource.Context}", c); }, token);
ReportMetricType(contextValueSource.Gauges,
g => { reporter.ReportMetric($"{contextValueSource.Context}", g); }, token);
ReportMetricType(contextValueSource.Histograms,
h => { reporter.ReportMetric($"{contextValueSource.Context}", h); }, token);
ReportMetricType(contextValueSource.Meters,
m => { reporter.ReportMetric($"{contextValueSource.Context}", m); }, token);
ReportMetricType(contextValueSource.Timers,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); }, token);
ReportMetricType(contextValueSource.ApdexScores,
t => { reporter.ReportMetric($"{contextValueSource.Context}", t); }, token);
}
var result = await reporter.EndAndFlushReportRunAsync(metrics);
_logger.ReportRan(reporter, startTimestamp);
return(result);
}
public MetricManagerConfig(IMetricReporter <T> metricReporter)
{
ParameterChecker.NotNull(metricReporter, "metricReporter");
MetricReporter = metricReporter;
}
internal Task Generate(IMetricReporter reporter,
IMetrics metrics,
CancellationToken token)
{
return(Generate(reporter, metrics, metrics.Advanced.GlobalFilter, token));
}
public static void ReportFailed(this ILogger logger, IMetricReporter reporter)
{
logger.LogError(AppMetricsEventIds.Reports.Schedule, $"{reporter.GetType()} failed during execution");
}
