public void AddMeasure(TCountType measure, ICountedConfig config, long value)
{
int num = this.ConvertMeasureToIndex(measure);
Count <TEntityType, TCountType> count = this.measures[num];
if (count == null)
{
count = this.CreateNewCount(measure, config, num);
}
count.AddValue(value);
this.lastAccessTime = this.timeProvider();
}
public Count(ICountedEntity <TEntityType> entity, ICountedConfig config, TCountType measure, Func <DateTime> timeProvider)
{
ArgumentValidator.ThrowIfNull("entity", entity);
ArgumentValidator.ThrowIfNull("config", config);
ArgumentValidator.ThrowIfNull("measure", measure);
ArgumentValidator.ThrowIfNull("timeProvider", timeProvider);
this.Entity = entity;
this.Config = config;
this.Measure = measure;
this.timeProvider = timeProvider;
this.lastAccessTime = this.timeProvider();
if (this.Config.TimeToLive != TimeSpan.Zero)
{
this.expirationTime = this.timeProvider().Add(this.Config.TimeToLive);
}
}
public static Count <TEntityType, TCountType> CreateCount <TEntityType, TCountType>(ICountedEntity <TEntityType> entity, TCountType measure, ICountedConfig config) where TEntityType : struct, IConvertible where TCountType : struct, IConvertible
{
return(CountFactory.CreateCount <TEntityType, TCountType>(entity, measure, config, () => DateTime.UtcNow));
}
public static Count <TEntityType, TCountType> CreateCount <TEntityType, TCountType>(ICountedEntity <TEntityType> entity, TCountType measure, ICountedConfig config, Func <DateTime> timeProvider) where TEntityType : struct, IConvertible where TCountType : struct, IConvertible
{
if (config is IRollingCountConfig)
{
return(new RollingCount <TEntityType, TCountType>(entity, (IRollingCountConfig)config, measure, timeProvider));
}
if (config is IAbsoluteCountConfig)
{
return(new AbsoluteCount <TEntityType, TCountType>(entity, (IAbsoluteCountConfig)config, measure, timeProvider));
}
throw new InvalidOperationException("Need to create a config of a subtype class of ICountedConfig");
}
public Task AddUsageAsync(ICountedEntity <TEntityType> entity, TCountType measure, ICountedConfig countConfig, long increment)
{
ArgumentValidator.ThrowIfNull("entity", entity);
ArgumentValidator.ThrowIfNull("countConfig", countConfig);
return(Task.Factory.StartNew(delegate()
{
this.AddUsage(entity, measure, countConfig, increment);
}));
}
private Count <TEntityType, TCountType> CreateNewCount(TCountType measure, ICountedConfig config, int measureIndex)
{
Count <TEntityType, TCountType> count;
lock (this.syncObject)
{
if (this.measures[measureIndex] == null)
{
count = CountFactory.CreateCount <TEntityType, TCountType>(this.entity, measure, config, this.timeProvider);
this.measures[measureIndex] = count;
}
else
{
count = this.measures[measureIndex];
}
}
this.perfCounters.MeasureAdded(measure);
return(count);
}
public void AddUsage(ICountedEntity <TEntityType> entity, TCountType measure, ICountedConfig countConfig, long increment)
{
ArgumentValidator.ThrowIfNull("entity", entity);
ArgumentValidator.ThrowIfNull("countConfig", countConfig);
CountTracker <TEntityType, TCountType> .EntityValue entityValue;
if (this.entities.TryGetValue(entity.Name, out entityValue))
{
entityValue.AddMeasure(measure, countConfig, increment);
return;
}
if (!countConfig.IsPromotable)
{
this.AddEntityAndMeasure(entity, measure, countConfig, increment);
return;
}
if (this.entities.Any((KeyValuePair <IEntityName <TEntityType>, CountTracker <TEntityType, TCountType> .EntityValue> e) => e.Value.Entity.GroupName.Equals(entity.GroupName)))
{
this.AddEntityAndMeasure(entity, measure, countConfig, increment);
return;
}
CountTracker <TEntityType, TCountType> .EntityKey entityKey = new CountTracker <TEntityType, TCountType> .EntityKey(entity.GroupName, measure);
long num = this.unpromotedMeasures.AddOrUpdate(entityKey, (CountTracker <TEntityType, TCountType> .EntityKey k) => increment, (CountTracker <TEntityType, TCountType> .EntityKey k, long v) => v + increment);
if (num > (long)countConfig.MinActivityThreshold)
{
this.AddEntityAndMeasure(entity, measure, countConfig, increment);
this.unpromotedMeasures.TryRemove(entityKey, out num);
this.tracer.TraceDebug <IEntityName <TEntityType>, TCountType, int>((long)this.GetHashCode(), "Promoted entity {0} and measure {1} for crossing threshold {2}", entityKey.Entity, entityKey.Measure, countConfig.MinActivityThreshold);
this.perfCounters.MeasurePromoted(measure);
}
}
private void AddEntityAndMeasure(ICountedEntity <TEntityType> entity, TCountType measure, ICountedConfig countConfig, long increment)
{
CountTracker <TEntityType, TCountType> .EntityValue entityValue = this.AddEntity(entity);
entityValue.AddMeasure(measure, countConfig, increment);
}
public Count(ICountedEntity <TEntityType> entity, ICountedConfig config, TCountType measure) : this(entity, config, measure, () => DateTime.UtcNow)
{
}
public Task AddUsageAsync(TCountType measure, ICountedConfig countConfig, int increment)
{
return(this.tracker.AddUsageAsync(this.Entity, measure, countConfig, (long)increment));
}
public void AddUsage(TCountType measure, ICountedConfig countConfig, int increment)
{
this.tracker.AddUsage(this.Entity, measure, countConfig, (long)increment);
}
