public async Task ReportMetricAsync_GetsValidInputWithOneDimensions_SuccessfullyWritesMetric()
{
// Arrange
var metricName = _bogus.Name.FirstName();
var metricDescription = _bogus.Lorem.Sentence();
var metricValue = _bogus.Random.Double();
var dimensionName = _bogus.Name.FirstName();
var dimensionValue = _bogus.Name.FirstName();
var expectedDimensionName = dimensionName.ToLower();
var timeSeries = new TimeSeriesElement
{
Metadatavalues = new List <MetadataValue> {
new MetadataValue(name: new LocalizableString(dimensionName), value: dimensionValue)
}
};
var measuredMetric = MeasuredMetric.CreateForDimension(metricValue, dimensionName.ToUpper(), timeSeries);
var scrapeResult = ScrapeResultGenerator.GenerateFromMetric(measuredMetric);
var metricsDeclarationProvider = CreateMetricsDeclarationProvider(metricName);
var prometheusConfiguration = CreatePrometheusConfiguration();
var mocks = CreatePrometheusMetricFactoryMock();
var metricSink = new PrometheusScrapingEndpointMetricSink(mocks.Factory.Object, metricsDeclarationProvider, prometheusConfiguration, NullLogger <PrometheusScrapingEndpointMetricSink> .Instance);
// Act
await metricSink.ReportMetricAsync(metricName, metricDescription, scrapeResult);
// Assert
mocks.Factory.Verify(mock => mock.CreateGauge(metricName, metricDescription, It.IsAny <bool>(), It.Is <string[]>(specified => specified.Contains(expectedDimensionName) && EnsureAllArrayEntriesAreSpecified(specified, scrapeResult.Labels.Keys.ToArray()))), Times.Once());
mocks.MetricFamily.Verify(mock => mock.WithLabels(It.Is <string[]>(specified => specified.Contains(dimensionValue) && EnsureAllArrayEntriesAreSpecified(specified, scrapeResult.Labels.Values.ToArray()))), Times.Once());
mocks.Gauge.Verify(mock => mock.Set(metricValue), Times.Once());
}
public static TimeSeries GetValues(string measurementId, string mrid, int?numberOf, TimeSpan?timespan, DateTime?fromDate, DateTime?toDate)
{
Device[] devices = Devices.Where(d => mrid == null || d.Mrid.StartsWith(mrid)).ToArray();
DateTime d0 = fromDate.HasValue ? fromDate.Value : StartDate;
DateTime d1 = toDate.HasValue ? toDate.Value : DateTime.Now;
TimeSpan total = d1.Subtract(d0);
int number = numberOf.HasValue ? numberOf.Value : (int)Math.Ceiling(total.Divide(timespan.Value));
TimeSpan diff = total.Divide(number);
TimeSeriesElement[] elements = new TimeSeriesElement[number];
DateTime di = d0;
for (int i = 0; i < elements.Length; i++, di += diff)
{
elements[i] = new TimeSeriesElement {
Date = di, Value = 0
};
}
foreach (Device device in devices)
{
for (int i = 0; i < elements.Length; i++)
{
elements[i].Value += GetFloatAt(elements[i].Date.Value, Devices.IndexOf(device));
}
}
return(new TimeSeries()
{
Data = new List <TimeSeriesElement>(elements), Typeid = measurementId
});
}
private MetricValue GetMostRecentMetricValue(string metricName, TimeSeriesElement timeSeries, DateTime recordDateTime)
{
var relevantMetricValue = timeSeries.Data.Where(metricValue => metricValue.TimeStamp < recordDateTime)
.OrderByDescending(metricValue => metricValue.TimeStamp)
.FirstOrDefault();
if (relevantMetricValue == null)
{
throw new MetricInformationNotFoundException(metricName, $"No time series entry was found recorded before {recordDateTime}");
}
return(relevantMetricValue);
}
private void AreEqual(TimeSeriesElement exp, TimeSeriesElement act)
{
if (exp != null)
{
Assert.NotNull(act);
AreEqual(exp.Data, act.Data);
AreEqual(exp.Metadatavalues, act.Metadatavalues);
}
else
{
Assert.Null(act);
}
}
/// <summary>
/// Create a measured metric for a given dimension
/// </summary>
/// <param name="value">Measured metric value</param>
/// <param name="dimensionName">Name of dimension that is being scraped</param>
/// <param name="timeseries">Timeseries representing one of the dimensions</param>
public static MeasuredMetric CreateForDimension(double?value, string dimensionName, TimeSeriesElement timeseries)
{
Guard.NotNullOrWhitespace(dimensionName, nameof(dimensionName));
Guard.NotNull(timeseries, nameof(timeseries));
Guard.For <ArgumentException>(() => timeseries.Metadatavalues.Any() == false);
var dimensionValue = timeseries.Metadatavalues.Single(metadataValue => metadataValue.Name?.Value.Equals(dimensionName, StringComparison.InvariantCultureIgnoreCase) == true);
return(CreateForDimension(value, dimensionName, dimensionValue.Value));
}
