/// <summary />
/// <param name="seriesCountLimit"></param>
/// <param name="valuesPerDimensionLimit"></param>
/// <param name="seriesConfig"></param>
public MetricConfiguration(
int seriesCountLimit,
int valuesPerDimensionLimit,
IMetricSeriesConfiguration seriesConfig)
{
if (seriesCountLimit < 1)
{
throw new ArgumentOutOfRangeException(
nameof(seriesCountLimit),
$"Metrics must allow at least one data series (but {seriesCountLimit} was specified).");
}
if (valuesPerDimensionLimit < 0)
{
throw new ArgumentOutOfRangeException(nameof(valuesPerDimensionLimit));
}
Util.ValidateNotNull(seriesConfig, nameof(seriesConfig));
SeriesCountLimit = seriesCountLimit;
ValuesPerDimensionLimit = valuesPerDimensionLimit;
SeriesConfig = seriesConfig;
_hashCode = Util.CombineHashCodes(
SeriesCountLimit.GetHashCode(),
ValuesPerDimensionLimit.GetHashCode(),
SeriesConfig.GetType().FullName.GetHashCode(),
SeriesConfig.GetHashCode());
}
/// <summary>Creates a new instance of <c>MetricConfiguration</c>.</summary>
/// <param name="seriesCountLimit">How many data time series a metric can contain as a maximum.
/// Once this limit is reached, calls to <c>TrackValue(..)</c>, <c>TryGetDataSeries(..)</c> and similar
/// that would normally result in new series will return <c>false</c>.</param>
/// <param name="valuesPerDimensionLimit">How many different values each of the dimensions of a metric can
/// have as a maximum.
/// Once this limit is reached, calls to <c>TrackValue(..)</c>, <c>TryGetDataSeries(..)</c> and similar
/// that would normally result in new series will return <c>false</c>.</param>
/// <param name="seriesConfig">The configuration for how each series of this metric should be aggregated.</param>
public MetricConfiguration(
int seriesCountLimit,
int valuesPerDimensionLimit,
IMetricSeriesConfiguration seriesConfig)
{
if (seriesCountLimit < 1)
{
throw new ArgumentOutOfRangeException(
nameof(seriesCountLimit),
Invariant($"Metrics must allow at least one data series (but {seriesCountLimit} was specified)."));
}
this.SeriesCountLimit = seriesCountLimit;
if (valuesPerDimensionLimit < 0)
{
throw new ArgumentOutOfRangeException(nameof(valuesPerDimensionLimit));
}
for (int d = 0; d < this.valuesPerDimensionLimits.Length; d++)
{
this.valuesPerDimensionLimits[d] = valuesPerDimensionLimit;
}
Util.ValidateNotNull(seriesConfig, nameof(seriesConfig));
this.SeriesConfig = seriesConfig;
this.hashCode = this.ComputeHashCode();
}
/// <summary>@ToDo: Complete documentation before stable release. {362}</summary>
/// <param name="metricNamespace">@ToDo: Complete documentation before stable release. {953}</param>
/// <param name="metricId">@ToDo: Complete documentation before stable release. {176}</param>
/// <param name="config">@ToDo: Complete documentation before stable release. {016}</param>
/// <returns>@ToDo: Complete documentation before stable release. {996}</returns>
public MetricSeries CreateNewSeries(string metricNamespace, string metricId, IMetricSeriesConfiguration config)
{
return(this.CreateNewSeries(
metricNamespace,
metricId,
dimensionNamesAndValues: null,
config: config));
}
/// <summary>
///
/// </summary>
/// <param name="metricId"></param>
/// <param name="config"></param>
/// <returns></returns>
public MetricSeries CreateNewSeries(string metricId, IMetricSeriesConfiguration config)
{
Util.ValidateNotNull(metricId, nameof(metricId));
Util.ValidateNotNull(config, nameof(config));
var dataSeries = new MetricSeries(_aggregationManager, metricId, null, config);
return(dataSeries);
}
public DataSeriesAggregatorBase(IMetricSeriesConfiguration configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind)
{
Util.ValidateNotNull(configuration, nameof(configuration));
_dataSeries = dataSeries;
_aggregationCycleKind = aggregationCycleKind;
_isPersistent = configuration.RequiresPersistentAggregation;
Reset(default(DateTimeOffset), default(IMetricValueFilter));
}
internal MetricSeries(
MetricAggregationManager aggregationManager,
string metricId,
IEnumerable <KeyValuePair <string, string> > dimensionNamesAndValues,
IMetricSeriesConfiguration configuration)
{
Util.ValidateNotNull(aggregationManager, nameof(aggregationManager));
Util.ValidateNotNull(metricId, nameof(metricId));
Util.ValidateNotNull(configuration, nameof(configuration));
_aggregationManager = aggregationManager;
_metricId = metricId;
_configuration = configuration;
_requiresPersistentAggregator = configuration.RequiresPersistentAggregation;
var dimNameVals = new Dictionary <string, string>();
if (dimensionNamesAndValues != null)
{
int dimIndex = 0;
foreach (KeyValuePair <string, string> dimNameVal in dimensionNamesAndValues)
{
if (dimNameVal.Key == null)
{
throw new ArgumentNullException($"The name for dimension at 0-based index '{dimIndex}' is null.");
}
if (String.IsNullOrWhiteSpace(dimNameVal.Key))
{
throw new ArgumentException($"The name for dimension at 0-based index '{dimIndex}' is empty or white-space");
}
if (dimNameVal.Value == null)
{
throw new ArgumentNullException($"The value for dimension '{dimNameVal.Key}' number is null.");
}
if (String.IsNullOrWhiteSpace(dimNameVal.Value))
{
throw new ArgumentNullException($"The value for dimension '{dimNameVal.Key}' is empty or white-space.");
}
dimNameVals[dimNameVal.Key] = dimNameVal.Value;
dimIndex++;
}
}
_dimensionNamesAndValues = dimNameVals;
_aggregatorPersistent = null;
_aggregatorDefault = null;
_aggregatorQuickPulse = null;
_aggregatorCustom = null;
}
/// <summary>Creates a new instance of <c>MetricConfiguration</c>.</summary>
/// <param name="seriesCountLimit">How many data time series a metric can contain as a maximum.
/// Once this limit is reached, calls to <c>TrackValue(..)</c>, <c>TryGetDataSeries(..)</c> and similar
/// that would normally result in new series will return <c>false</c>.</param>
/// <param name="valuesPerDimensionLimits">How many different values each of the dimensions of a metric can
/// have as a maximum. If this enumeration contains less elements than the number of supported dimensions,
/// then the last specified element is replicated for subsequent dimensions. If this enumeration contains
/// too many elements, superflous elements are ignored.
/// Once this limit is reached, calls to <c>TrackValue(..)</c>, <c>TryGetDataSeries(..)</c> and similar
/// that would normally result in new series will return <c>false</c>.</param>
/// <param name="seriesConfig">The configuration for how each series of this metric should be aggregated.</param>
public MetricConfiguration(
int seriesCountLimit,
IEnumerable <int> valuesPerDimensionLimits,
IMetricSeriesConfiguration seriesConfig)
{
if (seriesCountLimit < 1)
{
throw new ArgumentOutOfRangeException(
nameof(seriesCountLimit),
Invariant($"Metrics must allow at least one data series (but {seriesCountLimit} was specified)."));
}
this.SeriesCountLimit = seriesCountLimit;
if (valuesPerDimensionLimits == null)
{
throw new ArgumentNullException(nameof(valuesPerDimensionLimits));
}
int lastLim = 0, d = 0;
foreach (int lim in valuesPerDimensionLimits)
{
lastLim = lim;
if (lastLim < 0)
{
throw new ArgumentOutOfRangeException(nameof(valuesPerDimensionLimits) + "[" + d + "]");
}
this.valuesPerDimensionLimits[d] = lastLim;
d++;
if (d >= MetricIdentifier.MaxDimensionsCount)
{
break;
}
}
for (; d < this.valuesPerDimensionLimits.Length; d++)
{
this.valuesPerDimensionLimits[d] = lastLim;
}
Util.ValidateNotNull(seriesConfig, nameof(seriesConfig));
this.SeriesConfig = seriesConfig;
this.hashCode = this.ComputeHashCode();
}
public MetricSeriesAggregatorBase(
Func <MetricValuesBufferBase <TBufferedValue> > metricValuesBufferFactory,
IMetricSeriesConfiguration configuration,
MetricSeries dataSeries,
MetricAggregationCycleKind aggregationCycleKind)
{
Util.ValidateNotNull(metricValuesBufferFactory, nameof(metricValuesBufferFactory));
Util.ValidateNotNull(configuration, nameof(configuration));
_dataSeries = dataSeries;
_aggregationCycleKind = aggregationCycleKind;
_isPersistent = configuration.RequiresPersistentAggregation;
_metricValuesBufferFactory = metricValuesBufferFactory;
_metricValuesBuffer = InvokeMetricValuesBufferFactory();
Reset(default(DateTimeOffset), default(IMetricValueFilter));
}
public SimpleUInt32DataSeriesAggregator(IMetricSeriesConfiguration configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind)
: base(configuration, dataSeries, aggregationCycleKind)
{
Util.ValidateNotNull(configuration, nameof(configuration));
SimpleMetricSeriesConfiguration simpleSeriesConfig = configuration as SimpleMetricSeriesConfiguration;
if (simpleSeriesConfig == null)
{
throw new ArgumentException(
$"{nameof(SimpleUInt32DataSeriesAggregator)} expects a configuration of type {nameof(SimpleMetricSeriesConfiguration)},"
+ $" however the specified configuration is {configuration?.GetType()?.FullName ?? Util.NullString}.",
nameof(configuration));
}
if (false == simpleSeriesConfig.RestrictToUInt32Values)
{
throw new ArgumentException(
$"{nameof(SimpleUInt32DataSeriesAggregator)} expects a configuration of type {nameof(SimpleMetricSeriesConfiguration)}"
+ $" where 'RestrictToUInt32Values' is TRUE, however it is False.",
nameof(configuration));
}
}
/// <summary>@ToDo: Complete documentation before stable release. {064}</summary>
/// <param name="metricNamespace">@ToDo: Complete documentation before stable release. {831}</param>
/// <param name="metricId">@ToDo: Complete documentation before stable release. {381}</param>
/// <param name="dimensionNamesAndValues">@ToDo: Complete documentation before stable release. {374}</param>
/// <param name="config">@ToDo: Complete documentation before stable release. {303}</param>
/// <returns>@ToDo: Complete documentation before stable release. {866}</returns>
public MetricSeries CreateNewSeries(
string metricNamespace,
string metricId,
IEnumerable <KeyValuePair <string, string> > dimensionNamesAndValues,
IMetricSeriesConfiguration config)
{
// Create MetricIdentifier (it will also validate metricNamespace and metricId):
List <string> dimNames = null;
if (dimensionNamesAndValues != null)
{
dimNames = new List <string>();
foreach (KeyValuePair <string, string> dimNameVal in dimensionNamesAndValues)
{
dimNames.Add(dimNameVal.Key);
}
}
var metricIdentifier = new MetricIdentifier(metricNamespace, metricId, dimNames);
// Create series:
return(this.CreateNewSeries(metricIdentifier, dimensionNamesAndValues, config));
}
internal MetricSeries(
MetricAggregationManager aggregationManager,
MetricIdentifier metricIdentifier,
IEnumerable <KeyValuePair <string, string> > dimensionNamesAndValues,
IMetricSeriesConfiguration configuration)
{
// Validate and store aggregationManager:
Util.ValidateNotNull(aggregationManager, nameof(aggregationManager));
this.aggregationManager = aggregationManager;
// Validate and store metricIdentifier:
Util.ValidateNotNull(metricIdentifier, nameof(metricIdentifier));
this.MetricIdentifier = metricIdentifier;
// Copy dimensionNamesAndValues, validate values (keys are implicitly validated as they need to match the keys in the identifier):
var dimNameVals = new Dictionary <string, string>();
if (dimensionNamesAndValues != null)
{
int dimIndex = 0;
foreach (KeyValuePair <string, string> dimNameVal in dimensionNamesAndValues)
{
if (dimNameVal.Value == null)
{
throw new ArgumentNullException(Invariant($"The value for dimension '{dimNameVal.Key}' number is null."));
}
if (String.IsNullOrWhiteSpace(dimNameVal.Value))
{
throw new ArgumentNullException(Invariant($"The value for dimension '{dimNameVal.Key}' is empty or white-space."));
}
dimNameVals[dimNameVal.Key] = dimNameVal.Value;
dimIndex++;
}
}
// Validate that metricIdentifier and dimensionNamesAndValues contain consistent dimension names:
if (metricIdentifier.DimensionsCount != dimNameVals.Count)
{
throw new ArgumentException(Invariant($"The specified {nameof(metricIdentifier)} contains {metricIdentifier.DimensionsCount} dimensions,")
+ Invariant($" however the specified {nameof(dimensionNamesAndValues)} contains {dimNameVals.Count} name-value pairs with unique names."));
}
foreach (string dimName in metricIdentifier.GetDimensionNames())
{
if (false == dimNameVals.ContainsKey(dimName))
{
throw new ArgumentException(Invariant($"The specified {nameof(metricIdentifier)} contains a dimension named \"{dimName}\",")
+ Invariant($" however the specified {nameof(dimensionNamesAndValues)} does not contain an entry for that name."));
}
}
// Store copied dimensionNamesAndValues:
this.dimensionNamesAndValues = dimNameVals;
// Validate and store configuration:
Util.ValidateNotNull(configuration, nameof(configuration));
this.configuration = configuration;
this.requiresPersistentAggregator = configuration.RequiresPersistentAggregation;
// Init other instance vars:
this.aggregatorPersistent = null;
this.aggregatorDefault = null;
this.aggregatorQuickPulse = null;
this.aggregatorCustom = null;
}
/// <summary />
/// <param name="other"></param>
/// <returns></returns>
public bool Equals(IMetricSeriesConfiguration other)
{
return(Equals((object)other));
}
/// <summary>@ToDo: Complete documentation before stable release. {569}</summary>
/// <param name="metricIdentifier">@ToDo: Complete documentation before stable release. {108}</param>
/// <param name="dimensionNamesAndValues">@ToDo: Complete documentation before stable release. {785}</param>
/// <param name="config">@ToDo: Complete documentation before stable release. {275}</param>
/// <returns>@ToDo: Complete documentation before stable release. {908}</returns>
public MetricSeries CreateNewSeries(MetricIdentifier metricIdentifier, IEnumerable <KeyValuePair <string, string> > dimensionNamesAndValues, IMetricSeriesConfiguration config)
{
Util.ValidateNotNull(metricIdentifier, nameof(metricIdentifier));
Util.ValidateNotNull(config, nameof(config));
var dataSeries = new MetricSeries(this.aggregationManager, metricIdentifier, dimensionNamesAndValues, config);
return(dataSeries);
}
public SimpleNumberSeriesAggregatorBase(IMetricSeriesConfiguration configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind)
: base(configuration, dataSeries, aggregationCycleKind)
{
}
