public Task WriteAsync(
Stream output,
MetricsDataValueSource metricData,
CancellationToken cancellationToken)
{
var baseDate = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
var time = (metricData.Timestamp - baseDate).Ticks / 10000000;
var metrics = metricData.GetMackerelMetricsSnapshot()
.SelectMany(metricGroup =>
{
return(metricGroup.metric.SelectMany(metricValue =>
{
return ToMetricValues(_hostId, time, metricGroup, metricValue);
}));
});
using (var streamWriter = new StreamWriter(output))
{
using (var textWriter = new JsonTextWriter(streamWriter))
{
var serilizer = JsonSerializer.Create(_serializerSettings);
serilizer.Serialize(textWriter, metrics);
}
}
Logger.Debug(string.Join(",", metrics.Select(x => x.name)));
return(Task.CompletedTask);
}
/// <inheritdoc />
public Task WriteAsync(
Stream output,
MetricsDataValueSource metricsData,
CancellationToken cancellationToken = default)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var serializer = new MetricSnapshotSerializer();
using (var streamWriter = new StreamWriter(output))
{
using (var textWriter = new MetricSnapshotHostedMetricsJsonWriter(
streamWriter,
_flushInterval,
_options.MetricNameFormatter))
{
serializer.Serialize(textWriter, metricsData, MetricFields);
}
}
#if !NETSTANDARD1_6
return(AppMetricsTaskHelper.CompletedTask());
#else
return(Task.CompletedTask);
#endif
}
public async Task WriteAsync(
Stream output,
MetricsDataValueSource snapshot,
CancellationToken cancellationToken = default(CancellationToken))
{
using (var writer = new StreamWriter(output))
{
foreach (var timer in snapshot.Contexts.SelectMany(c => c.Timers))
{
await writer.WriteLineAsync(
$"{timer.Name} - " +
$"{timer.Value.Rate.Count} total. Rates: " +
$"{timer.Value.Rate.MeanRate:0} mean, " +
$"{timer.Value.Rate.OneMinuteRate:0} 1-min, " +
$"{timer.Value.Rate.FiveMinuteRate:0} 5-min. #metric");
}
foreach (var counter in snapshot.Contexts.SelectMany(c => c.Counters))
{
await writer.WriteLineAsync(
$"{counter.Name} - " +
$"{counter.Value.Count} total.");
}
}
}
public Task WriteAsync(Stream output, MetricsDataValueSource metricsData, CancellationToken cancellationToken = default(CancellationToken))
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var serilizerJson = JsonSerializer.Create();
//using (var streamWriter = new StreamWriter(output))
//{
// // TODO: #251 should apply metric field names
// using (var textWriter = new JsonTextWriter(streamWriter))
// {
// serilizerJson.Serialize(textWriter, metricsData);
// }
//}
var serializer = new MetricSnapshotSerializer();
using (var streamWriter = new StreamWriter(output))
{
using (var textWriter = new MetricSnapshotAliTSDBLineProtocolWriter(streamWriter, _options.MetricNameFormatter))
{
serializer.Serialize(textWriter, metricsData);
}
}
#if !NETSTANDARD1_6
return(AppMetricsTaskHelper.CompletedTask());
#else
return(Task.CompletedTask);
#endif
}
/// <inheritdoc />
public Task WriteAsync(
Stream output,
MetricsDataValueSource metricsData,
CancellationToken cancellationToken = default)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var serializer = new MetricSnapshotSerializer();
using (var streamWriter = new StreamWriter(output, _options.Encoding, bufferSize: 1024, leaveOpen: true))
{
using (var textWriter = new MetricSnapshotTextWriter(
streamWriter,
_options.Separator,
_options.Padding,
_options.MetricNameFormatter))
{
serializer.Serialize(textWriter, metricsData, MetricFields);
}
}
#if NETSTANDARD1_6
return(Task.CompletedTask);
#else
return(AppMetricsTaskHelper.CompletedTask());
#endif
}
private async Task <bool> WriteChunkedOutput(
IMetricsChunkedOutputFormatter formatter,
MetricsDataValueSource metricsData,
CancellationToken cancellationToken = default)
{
Logger.Trace("Flushing chunked metrics snapshot");
var chunks = await formatter.WriteAsync(
metricsData,
_options.SocketSettings.MaxUdpDatagramSize,
cancellationToken);
var success = true;
foreach (var chunk in chunks)
{
var result = await _socketClient.WriteAsync(chunk, cancellationToken);
if (!result.Success)
{
Logger.Error(result.ErrorMessage);
success = false;
}
}
Logger.Trace(success
? "Successfully flushed chunked metrics snapshot"
: "Flushed chunked metrics snapshot with error(s)");
return(success);
}
/// <inheritdoc />
public Task WriteAsync(
Stream output,
MetricsDataValueSource metricData,
CancellationToken cancellationToken = default)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var serilizer = JsonSerializer.Create(_serializerSettings);
using (var streamWriter = new StreamWriter(output))
{
using (var textWriter = new JsonTextWriter(streamWriter))
{
serilizer.Serialize(textWriter, metricData);
}
}
#if NETSTANDARD1_6
return(Task.CompletedTask);
#else
return(AppMetricsTaskHelper.CompletedTask());
#endif
}
/// <summary>
/// Serializes the specified <see cref="MetricsDataValueSource" /> and writes the metrics snapshot using the specified
/// <see cref="IMetricSnapshotWriter" />.
/// </summary>
/// <param name="writer">The <see cref="IMetricSnapshotWriter" /> used to write the metrics snapshot.</param>
/// <param name="metricsData">The <see cref="MetricsDataValueSource" /> to serilize.</param>
/// <param name="fields">The metric fields to write</param>
public void Serialize(IMetricSnapshotWriter writer, MetricsDataValueSource metricsData, MetricFields fields)
{
foreach (var contextValueSource in metricsData.Contexts)
{
foreach (var valueSource in contextValueSource.ApdexScores)
{
BuildMetricPayload(contextValueSource.Context, valueSource, writer, fields, metricsData.Timestamp);
}
foreach (var valueSource in contextValueSource.Gauges)
{
BuildMetricPayload(contextValueSource.Context, valueSource, writer, fields, metricsData.Timestamp);
}
foreach (var valueSource in contextValueSource.Counters)
{
BuildMetricPayload(contextValueSource.Context, valueSource, writer, fields, metricsData.Timestamp);
}
foreach (var valueSource in contextValueSource.Meters)
{
BuildMetricPayload(contextValueSource.Context, valueSource, writer, fields, metricsData.Timestamp);
}
foreach (var valueSource in contextValueSource.Timers)
{
BuildMetricPayload(contextValueSource.Context, valueSource, writer, fields, metricsData.Timestamp);
}
foreach (var valueSource in contextValueSource.Histograms)
{
BuildMetricPayload(contextValueSource.Context, valueSource, writer, fields, metricsData.Timestamp);
}
}
}
/// <inheritdoc />
public Task <bool> FlushAsync(MetricsDataValueSource metricsData, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested || metricsData == null)
{
return(Task.FromResult(false));
}
var sw = Stopwatch.StartNew();
var now = DateTimeOffset.Now;
var count = 0;
foreach (var ctx in metricsData.Contexts)
{
var context = Filter != null?ctx.Filter(Filter) : ctx;
foreach (var mt in translator.Translate(context, now))
{
// Although the method comment suggest it is internal and should not be used,
// the documentation here https://docs.microsoft.com/en-us/azure/azure-monitor/app/api-custom-events-metrics
// suggest this is exactly the method you should use when metrics pre-aggregation is done by your code.
client.Track(mt);
++count;
}
}
if (count > 0)
{
client.Flush();
Logger.Trace($"Flushed TelemetryClient; {count} records; elapsed: {sw.Elapsed}.");
}
return(Task.FromResult(true));
}
/// <inheritdoc />
public Task WriteAsync(
Stream output,
MetricsDataValueSource metricsData,
CancellationToken cancellationToken = default)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var serializer = new MetricSnapshotSerializer();
using (var streamWriter = new StreamWriter(output))
{
using (var textWriter = new MetricSnapshotGraphitePlainTextProtocolWriter(
streamWriter,
_options.MetricPointTextWriter,
_options.MetricNameMapping))
{
serializer.Serialize(textWriter, metricsData);
}
}
#if !NETSTANDARD1_6
return(AppMetricsTaskHelper.CompletedTask());
#else
return(Task.CompletedTask);
#endif
}
/// <inheritdoc />
public Task <bool> FlushAsync(MetricsDataValueSource metricsData, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested || metricsData == null)
{
return(Task.FromResult(false));
}
var sw = Stopwatch.StartNew();
var now = DateTimeOffset.Now;
var count = 0;
foreach (var ctx in metricsData.Contexts)
{
foreach (var mt in TranslateContext(ctx, now))
{
client.TrackMetric(mt);
++count;
}
}
if (count <= 0)
{
return(Task.FromResult(true));
}
client.Flush();
Logger.Trace($"Flushed TelemetryClient; {count} records; elapsed: {sw.Elapsed}.");
return(Task.FromResult(true));
}
public async Task Counter_with_custom_sample_rate_with_multiple_MetricsDataValueSource_should_sample_correctly()
{
// Arrange
var sources = new List <MetricsDataValueSource>();
var timeStamp = _timestamp;
// Act
for (var i = 0; i < 10000; ++i)
{
sources.Add(CreateMetricsDataValueSource(ref timeStamp));
}
var emittedDataCount = (await Serialize(sources, 0.5)).Split('\n').Length;
// Assert
(emittedDataCount > 4500 && emittedDataCount < 5500).Should().BeTrue();
MetricsDataValueSource CreateMetricsDataValueSource(ref DateTime timestamp)
{
var counter = new DefaultCounterMetric();
counter.Increment(1);
var counterValueSource = new CounterValueSource(
"test counter",
ConstantValue.Provider(counter.Value),
Unit.None,
MetricTags.Empty);
var valueSource = CreateValueSource("test", counters: counterValueSource);
var result = new MetricsDataValueSource(timestamp, new[] { valueSource });
timestamp += TimeSpan.FromSeconds(1);
return(result);
}
}
/// <inheritdoc />
public async Task <bool> FlushAsync(MetricsDataValueSource metricsData, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested || metricsData == null)
{
return(false);
}
var sw = Stopwatch.StartNew();
var now = DateTimeOffset.Now;
var count = 0;
var data = new List <MetricDatum>();
foreach (var ctx in metricsData.Contexts)
{
foreach (var mt in TranslateContext(ctx, now))
{
data.Add(mt);
++count;
}
}
if (count > 0)
{
await _client.PutMetricDataAsync(new PutMetricDataRequest
{
MetricData = data,
Namespace = CustomNamespace
});
Logger.Trace($"Flushed TelemetryClient; {count} records; elapsed: {sw.Elapsed}.");
}
return(true);
}
public MetricsDataValueSource GetData(IMetricsFilter filter)
{
_logger.RetrievedMetricsData();
if (_contexts.Count == 0)
{
return(MetricsDataValueSource.Empty);
}
var environment = _environmentInfoProvider.Build();
var contexts = _contexts.Values.Select(g => new MetricsContextValueSource(
g.Context,
g.DataProvider.Gauges.ToArray(),
g.DataProvider.Counters.ToArray(),
g.DataProvider.Meters.ToArray(),
g.DataProvider.Histograms.ToArray(),
g.DataProvider.Timers.ToArray(),
g.DataProvider.ApdexScores.ToArray()
));
var data = new MetricsDataValueSource(_clock.UtcDateTime, environment, contexts);
_logger.GettingMetricsData();
return(data.Filter(filter));
}
public MetricsDataValueSource GetData(IFilterMetrics filter)
{
Logger.Trace("Getting metrics snaphot");
if (_nullMetricsRegistry.IsValueCreated)
{
Logger.Trace("Using null metrics registry");
_nullMetricsRegistry.Value.GetData(filter);
}
if (_contexts.Count == 0)
{
Logger.Trace("No metrics recorded");
return(MetricsDataValueSource.Empty);
}
Logger.Trace("Metrics snapshot retrieved containing {ContextCount} contexts", _contexts.Count);
var contexts = _contexts.Values.Select(
g => new MetricsContextValueSource(
g.Context,
g.DataProvider.Gauges.ToArray(),
g.DataProvider.Counters.ToArray(),
g.DataProvider.Meters.ToArray(),
g.DataProvider.Histograms.ToArray(),
g.DataProvider.Timers.ToArray(),
g.DataProvider.ApdexScores.ToArray()));
var data = new MetricsDataValueSource(_clock.UtcDateTime, contexts);
return(data.Filter(filter));
}
public void Build <TPayload>(MetricsDataValueSource metricsData, IMetricPayloadBuilder <TPayload> payloadBuilder)
{
foreach (var contextValueSource in metricsData.Contexts)
{
foreach (var valueSource in contextValueSource.ApdexScores)
{
BuildMetricPayload(contextValueSource.Context, valueSource, payloadBuilder);
}
foreach (var valueSource in contextValueSource.Gauges)
{
BuildMetricPayload(contextValueSource.Context, valueSource, payloadBuilder);
}
foreach (var valueSource in contextValueSource.Counters)
{
BuildMetricPayload(contextValueSource.Context, valueSource, payloadBuilder);
}
foreach (var valueSource in contextValueSource.Meters)
{
BuildMetricPayload(contextValueSource.Context, valueSource, payloadBuilder);
}
foreach (var valueSource in contextValueSource.Timers)
{
BuildMetricPayload(contextValueSource.Context, valueSource, payloadBuilder);
}
foreach (var valueSource in contextValueSource.Histograms)
{
BuildMetricPayload(contextValueSource.Context, valueSource, payloadBuilder);
}
}
}
/// <inheritdoc />
public async Task <bool> FlushAsync(MetricsDataValueSource metricsData, CancellationToken cancellationToken = default)
{
if (_socketClient.PreferChunkedOutput && Formatter is IMetricsChunkedOutputFormatter formatter)
{
return(await WriteChunkedOutput(formatter, metricsData, cancellationToken));
}
return(await WriteOutput(metricsData, cancellationToken));
}
public Task <bool> FlushAsync(MetricsDataValueSource metricsData, CancellationToken cancellationToken = default)
{
if (_throwEx != null)
{
throw _throwEx;
}
return(Task.FromResult(_pass));
}
/// <inheritdoc />
public Task WriteAsync(Stream output, MetricsDataValueSource metricsData, CancellationToken cancellationToken = default(CancellationToken))
{
using (var metricSnapshotWriter = new SerilogMetricSnapshotWriter(_options))
{
_serializer.Serialize(metricSnapshotWriter, metricsData, MetricFields);
}
return(Task.CompletedTask);
}
public MyHostedSvc()
{
metrics = new MetricsBuilder().Build();
metrCounter = new CounterOptions {
Name = "AppMetrics_Use"
};
metrics.Measure.Counter.Increment(metrCounter);
snapshot = metrics.Snapshot.Get(); // filters avilable
}
public Task WriteAsync(HttpContext context, MetricsDataValueSource metricsData, CancellationToken token = default(CancellationToken))
{
var payloadBuilder = new AsciiMetricPayloadBuilder();
var builder = new MetricDataValueSourceFormatter();
builder.Build(metricsData, payloadBuilder);
return(context.Response.WriteAsync(payloadBuilder.PayloadFormatted(), token));
}
private async Task WriteAsync(
MetricsDataValueSource metricsData,
CancellationToken cancellationToken = default)
{
var serializer = new MetricSnapshotSerializer();
await using var writer = new MetricSnapshotWavefrontWriter(wavefrontSender, source,
globalTags, histogramGranularities, sdkMetricsRegistry, metricFields);
serializer.Serialize(writer, metricsData, metricFields);
}
public static MetricData ToMetric(this MetricsDataValueSource source)
{
var jsonContexts = source.Contexts.ToSerializableMetric();
return(new MetricData
{
Timestamp = source.Timestamp,
Contexts = jsonContexts.ToArray()
});
}
public async Task <byte[]> GetSnapshot(CancellationToken cancellationToken)
{
using (var ms = new MemoryStream())
{
MetricsDataValueSource metricsData = this.metricsRoot.Snapshot.Get();
IMetricsOutputFormatter formatter = this.metricsRoot.DefaultOutputMetricsFormatter;
await formatter.WriteAsync(ms, metricsData, cancellationToken);
return(ms.ToArray());
}
}
private static async Task PrintMetrics(MetricsDataValueSource snapshot, IMetricsOutputFormatter formatter)
{
using (var stream = new MemoryStream())
{
await formatter.WriteAsync(stream, snapshot);
var result = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(result);
}
}
public static MetricData ToMetric(this MetricsDataValueSource source)
{
var jsonContexts = source.Contexts.ToMetric();
return(new MetricData
{
Environment = source.Environment.ToEnvDictionary(),
Timestamp = source.Timestamp,
Contexts = jsonContexts.ToArray()
});
}
/// <inheritdoc />
public Task WriteAsync(Stream output, MetricsDataValueSource metricsData, CancellationToken cancellationToken = new CancellationToken())
{
var serializer = new MetricSnapshotSerializer();
using (var streamWriter = new StreamWriter(output))
{
using (var writer = new MetricSnapshotDatadogWriter(streamWriter, _options))
serializer.Serialize(writer, metricsData);
}
return(Task.CompletedTask);
}
