public void RunReport(MetricsData metricsData, Func<HealthStatus> healthStatus, CancellationToken token)
{
using (log.Timing("Report of metrics data to Google Analytics"))
{
tracker.Track(metricsData.AsGoogleAnalytics(), token).Wait(token);
}
}
public static IEnumerable<Google.ICanReportToGoogleAnalytics> Map(MetricsData metricData)
{
using (log.Timing("Map Metrics.NET Data to Google Analytics Reports"))
{
return Map(metricData, null);
}
}
public static void VerifyRollBackCount(string queueName, MetricsData data, long messageCount, int rollbackCount, int failedCount)
{
var found = false;
const string name = "RollbackMessage.RollbackCounter";
const string retryName = "MessageFailedProcessingRetryMeter";
foreach (var metric in data.Counters.Where(counter => counter.Name.EndsWith(name, StringComparison.InvariantCultureIgnoreCase)))
{
Assert.Equal(messageCount * rollbackCount, metric.Value.Count);
found = true;
break;
}
if (!found)
{
throw new DotNetWorkQueueException($"Failed to find metric {name}");
}
if (failedCount > 0)
{
found = false;
foreach (
var metric in
data.Meters.Where(
counter => counter.Name.EndsWith(retryName, StringComparison.InvariantCultureIgnoreCase)))
{
Assert.Equal(messageCount*failedCount, metric.Value.Count);
found = true;
break;
}
if (!found)
{
throw new DotNetWorkQueueException($"Failed to find metric {name}");
}
}
}
public static string BuildJson(MetricsData data, IEnumerable<EnvironmentEntry> environment, Clock clock, bool indented = DefaultIndented)
{
var version = Version.ToString(CultureInfo.InvariantCulture);
return JsonMetricsContext.FromContext(data, environment, version)
.ToJsonObject()
.AsJson(indented);
}
private static IEnumerable<Google.ICanReportToGoogleAnalytics> Map(MetricsData metricData, string context)
{
return Map(metricData.Counters, context)
.Concat(Map(metricData.Gauges, context))
.Concat(Map(metricData.Histograms, context))
.Concat(Map(metricData.Meters, context))
.Concat(Map(metricData.Timers, context))
.Union(metricData.ChildMetrics.SelectMany(m => Map(m, m.Context)));
}
public void RunReport(MetricsData metricsData, Func<HealthStatus> healthStatus, CancellationToken token)
{
foreach (var timer in metricsData.Timers)
{
var timerValue = timer.ValueProvider.GetValue(resetMetric: true);
Console.WriteLine("{0} : {1} {2} {3}", timer.Name, timerValue.Rate.Count, timerValue.Histogram.Count, timerValue.Histogram.Percentile75);
}
}
public static string BuildJson(MetricsData data, Clock clock, bool indented = DefaultIndented)
{
var flatData = data.OldFormat();
return new JsonBuilderV1()
.AddVersion(Version)
.AddTimestamp(Clock.Default)
.AddEnvironment()
.AddObject(flatData.Gauges)
.AddObject(flatData.Counters)
.AddObject(flatData.Meters)
.AddObject(flatData.Histograms)
.AddObject(flatData.Timers)
.GetJson(indented);
}
public static JsonMetricsContext FromContext(MetricsData contextData, IEnumerable<EnvironmentEntry> environment, string version)
{
return new JsonMetricsContext
{
Version = version,
Timestamp = contextData.Timestamp,
Environment = contextData.Environment.Union(environment).ToDictionary(e => e.Name, e => e.Value),
Context = contextData.Context,
Gauges = contextData.Gauges.Select(JsonGauge.FromGauge).ToArray(),
Counters = contextData.Counters.Select(JsonCounter.FromCounter).ToArray(),
Meters = contextData.Meters.Select(JsonMeter.FromMeter).ToArray(),
Histograms = contextData.Histograms.Select(JsonHistogram.FromHistogram).ToArray(),
Timers = contextData.Timers.Select(JsonTimer.FromTimer).ToArray(),
ChildContexts = contextData.ChildMetrics.Select(FromContext).ToArray()
};
}
public static long GetExpiredMessageCount(MetricsData data)
{
var names = new List<string>(2) { ".ClearMessages.ResetCounter", ".Handle.Expired" };
long count = 0;
foreach (var name in names)
{
foreach (
var metric in
data.Counters.Where(
counter => counter.Name.EndsWith(name, StringComparison.InvariantCultureIgnoreCase)))
{
count = count + metric.Value.Count;
break;
}
}
return count;
}
public static long GetPoisonMessageCount(MetricsData data)
{
var names = new List<string>(1) { "PoisonHandleMeter" };
long count = 0;
foreach (var name in names)
{
foreach (
var metric in
data.Meters.Where(
counter => counter.Name.EndsWith(name, StringComparison.InvariantCultureIgnoreCase)))
{
count = count + metric.Value.Count;
break;
}
}
return count;
}
private async Task UpdateMetrics(Uri remoteUri, Func<string, JsonMetricsContext> deserializer, CancellationToken token)
{
try
{
var remoteContext = await HttpRemoteMetrics.FetchRemoteMetrics(remoteUri, deserializer, token).ConfigureAwait(false);
remoteContext.Environment.Add("RemoteUri", remoteUri.ToString());
remoteContext.Environment.Add("RemoteVersion", remoteContext.Version);
remoteContext.Environment.Add("RemoteTimestamp", Clock.FormatTimestamp(remoteContext.Timestamp));
this.currentData = remoteContext.ToMetricsData();
}
catch (Exception x)
{
MetricsErrorHandler.Handle(x, "Error updating metrics data from " + remoteUri);
this.currentData = MetricsData.Empty;
}
}
public static void VerifyProducedAsyncCount(string queueName, MetricsData data, long messageCount)
{
var found = false;
var name = "SendMessagesMeter";
foreach (var meter in data.Meters.Where(timer => timer.Name.EndsWith(name, StringComparison.InvariantCultureIgnoreCase)))
{
Assert.Equal(messageCount, meter.Value.Count);
found = true;
break;
}
if (!found)
{
throw new DotNetWorkQueueException($"Failed to find timer {name}");
}
}
public static string RenderMetrics(MetricsData metricsData, Func<HealthStatus> healthStatus)
{
var report = new StringReport();
report.RunReport(metricsData, healthStatus, CancellationToken.None);
return report.Result;
}
public static JsonMetricsContext FromContext(MetricsData contextData)
{
return FromContext(contextData, null);
}
public static JsonMetricsContext FromContext(MetricsData contextData, string version)
{
return FromContext(contextData, Enumerable.Empty<EnvironmentEntry>(), version);
}
public static void VerifyProcessedCount(string queueName, MetricsData data, long messageCount)
{
var found = false;
const string name = "CommitMessage.CommitCounter";
foreach (var counter in data.Counters.Where(counter => counter.Name.EndsWith(name, StringComparison.InvariantCultureIgnoreCase)))
{
Assert.Equal(messageCount, counter.Value.Count);
found = true;
break;
}
if (!found)
{
throw new DotNetWorkQueueException($"Failed to find timer {name}");
}
}
public static void VerifyExpiredMessageCount(string queueName, MetricsData data, long messageCount)
{
var count = GetExpiredMessageCount(data);
Assert.Equal(messageCount, count);
}
public MetricsData(string context, IEnumerable <EnvironmentEntry> environment, MetricsData data, IEnumerable <MetricsData> childMetrics)
: this(context, environment, data.Gauges, data.Counters, data.Meters, data.Histograms, data.Timers, childMetrics)
{
}
public static string BuildJson(MetricsData data) { return BuildJson(data, Clock.Default, indented: DefaultIndented); }
public static string BuildJson(MetricsData data)
{
return BuildJson(data, AppEnvironment.Current, Clock.Default, indented: DefaultIndented);
}