private AggregationPeriodSummary CycleAggregators(
ref AggregatorCollection aggregators,
DateTimeOffset tactTimestamp,
IMetricSeriesFilter futureFilter,
bool stopAggregators)
{
if (aggregators == _aggregatorsForPersistent)
{
throw new InvalidOperationException("Invernal SDK bug. Please report. Cannot cycle persistent aggregators.");
}
tactTimestamp = Util.RoundDownToSecond(tactTimestamp);
// For non-persistent aggregators: create empty holder for the next aggregation period and swap for the previous holder:
AggregatorCollection prevAggregators;
if (stopAggregators)
{
prevAggregators = Interlocked.Exchange(ref aggregators, null);
}
else
{
AggregatorCollection nextAggregators = new AggregatorCollection(tactTimestamp, futureFilter);
prevAggregators = Interlocked.Exchange(ref aggregators, nextAggregators);
}
List <MetricAggregate> persistentValsAggregations = GetPersistentAggregations(tactTimestamp, prevAggregators?.Filter);
List <MetricAggregate> nonpersistentAggregations = GetNonpersistentAggregations(tactTimestamp, prevAggregators);
var summary = new AggregationPeriodSummary(persistentValsAggregations, nonpersistentAggregations);
return(summary);
}
internal MetricAggregationManager()
{
DateTimeOffset now = DateTimeOffset.Now;
DateTimeOffset timestamp = Util.RoundDownToSecond(now);
_aggregatorsForDefault = new AggregatorCollection(timestamp, filter: null);
_aggregatorsForPersistent = new AggregatorCollection(timestamp, filter: null);
}
internal bool IsCycleActive(MetricAggregationCycleKind aggregationCycleKind, out IMetricSeriesFilter filter)
{
switch (aggregationCycleKind)
{
case CycleKind.Default:
filter = null;
return(true);
case CycleKind.QuickPulse:
case CycleKind.Custom:
AggregatorCollection aggs = (aggregationCycleKind == CycleKind.QuickPulse) ? _aggregatorsForQuickPulse : _aggregatorsForCustom;
filter = aggs?.Filter;
return(aggs != null);
default:
throw new ArgumentException($"Unexpected value of {nameof(aggregationCycleKind)}: {aggregationCycleKind}.");
}
}
private static bool AddAggregator(IMetricSeriesAggregator aggregator, AggregatorCollection aggregatorCollection)
{
if (aggregatorCollection == null)
{
return(false);
}
IMetricSeriesFilter seriesFilter = aggregatorCollection.Filter;
IMetricValueFilter valueFilter = null;
if (seriesFilter != null && !seriesFilter.WillConsume(aggregator.DataSeries, out valueFilter))
{
return(false);
}
aggregator.Reset(aggregatorCollection.PeriodStart, valueFilter);
aggregatorCollection.Aggregators.Add(aggregator);
return(true);
}
private static bool AddAggregator(IMetricSeriesAggregator aggregator, AggregatorCollection aggregatorCollection)
{
if (aggregatorCollection == null)
{
return(false);
}
IMetricSeriesFilter seriesFilter = aggregatorCollection.Filter;
IMetricValueFilter valueFilter;
if (false == Util.FilterWillConsume(seriesFilter, aggregator.DataSeries, out valueFilter))
{
return(false);
}
// @ToDo
// @PublicExposureCandidate
// aggregator.Reset(aggregatorCollection.PeriodStart, valueFilter);
aggregator.Reset(aggregatorCollection.PeriodStart);
aggregatorCollection.Aggregators.Add(aggregator);
return(true);
}
private List <MetricAggregate> GetNonpersistentAggregations(DateTimeOffset tactTimestamp, AggregatorCollection aggregators)
{
// Complete each non-persistent aggregator:
// (we snapshotted the entire collection, so Count is stable)
GrowingCollection <IMetricSeriesAggregator> actualAggregators = aggregators?.Aggregators;
if (null == actualAggregators || 0 == actualAggregators.Count)
{
return(new List <MetricAggregate>(capacity: 0));
}
List <MetricAggregate> nonpersistentAggregations = new List <MetricAggregate>(capacity: actualAggregators.Count);
foreach (IMetricSeriesAggregator aggregator in actualAggregators)
{
if (aggregator != null)
{
MetricAggregate aggregate = aggregator.CompleteAggregation(tactTimestamp);
if (aggregate != null)
{
nonpersistentAggregations.Add(aggregate);
}
}
}
return(nonpersistentAggregations);
}
