public QueueTrackingStatistic(string queueName)
{
if (StatisticsCollector.CollectQueueStats)
{
const CounterStorage storage = CounterStorage.LogAndTable;
averageQueueSizeCounter = AverageValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_QUEUE_SIZE_AVERAGE_PER_QUEUE, queueName), storage);
numEnqueuedRequestsCounter = CounterStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_ENQUEUED_PER_QUEUE, queueName), false, storage);
if (TrackExtraStats)
{
totalExecutionTime = TimeIntervalFactory.CreateTimeInterval(true);
averageArrivalRate = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_AVERAGE_ARRIVAL_RATE_PER_QUEUE, queueName),
() =>
{
TimeSpan totalTime = totalExecutionTime.Elapsed;
if (totalTime.Ticks == 0)
{
return(0);
}
long numReqs = numEnqueuedRequestsCounter.GetCurrentValue();
return((float)((((double)numReqs * (double)TimeSpan.TicksPerSecond)) / (double)totalTime.Ticks));
}, storage);
}
averageTimeInQueue = AverageValueStatistic.FindOrCreate(new StatisticName(StatisticNames.QUEUES_TIME_IN_QUEUE_AVERAGE_MILLIS_PER_QUEUE, queueName), storage);
averageTimeInQueue.AddValueConverter(Utils.AverageTicksToMilliSeconds);
if (averageTimeInAllQueues == null)
{
averageTimeInAllQueues = AverageValueStatistic.FindOrCreate(new StatisticName(StatisticNames.QUEUES_TIME_IN_QUEUE_AVERAGE_MILLIS_PER_QUEUE, "AllQueues"), storage);
averageTimeInAllQueues.AddValueConverter(Utils.AverageTicksToMilliSeconds);
}
if (totalTimeInAllQueues == null)
{
totalTimeInAllQueues = CounterStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_TIME_IN_QUEUE_TOTAL_MILLIS_PER_QUEUE, "AllQueues"), false, storage);
totalTimeInAllQueues.AddValueConverter(Utils.TicksToMilliSeconds);
}
}
}
/// <summary>
/// Start this callback timer
/// </summary>
/// <param name="time">Timeout time</param>
public void StartTimer(TimeSpan time)
{
if (time < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException("time", "The timeout parameter is negative.");
}
timeout = time;
if (StatisticsCollector.CollectApplicationRequestsStats)
{
timeSinceIssued = TimeIntervalFactory.CreateTimeInterval(true);
timeSinceIssued.Start();
}
TimeSpan firstPeriod = timeout;
TimeSpan repeatPeriod = Constants.INFINITE_TIMESPAN; // Single timeout period --> No repeat
if (Config.ResendOnTimeout && Config.MaxResendCount > 0)
{
firstPeriod = repeatPeriod = timeout.Divide(Config.MaxResendCount + 1);
}
// Start time running
DisposeTimer();
timer = new SafeTimer(TimeoutCallback, null, firstPeriod, repeatPeriod);
}
public void Start()
{
timeInterval = TimeIntervalFactory.CreateTimeInterval(true);
timeInterval.Start();
}
/// <summary>
/// Keep track of thread statistics, mainly timing, can be created outside the thread to be tracked.
/// </summary>
/// <param name="threadName">Name used for logging the collected stastistics</param>
/// <param name="storage"></param>
public ThreadTrackingStatistic(string threadName)
{
ExecutingCpuCycleTime = new TimeIntervalThreadCycleCounterBased();
ExecutingWallClockTime = TimeIntervalFactory.CreateTimeInterval(true);
ProcessingCpuCycleTime = new TimeIntervalThreadCycleCounterBased();
ProcessingWallClockTime = TimeIntervalFactory.CreateTimeInterval(true);
NumRequests = 0;
firstStart = true;
Name = threadName;
CounterStorage storage = StatisticsCollector.ReportDetailedThreadTimeTrackingStats ? CounterStorage.LogOnly : CounterStorage.DontStore;
CounterStorage aggrCountersStorage = CounterStorage.LogOnly;
// 4 direct counters
allExecutingCpuCycleTime.Add(
FloatValueStatistic.FindOrCreate(new StatisticName(StatisticNames.THREADS_EXECUTION_TIME_TOTAL_CPU_CYCLES, threadName),
() => (float)ExecutingCpuCycleTime.Elapsed.TotalMilliseconds, storage));
allExecutingWallClockTime.Add(
FloatValueStatistic.FindOrCreate(new StatisticName(StatisticNames.THREADS_EXECUTION_TIME_TOTAL_WALL_CLOCK, threadName),
() => (float)ExecutingWallClockTime.Elapsed.TotalMilliseconds, storage));
allProcessingCpuCycleTime.Add(
FloatValueStatistic.FindOrCreate(new StatisticName(StatisticNames.THREADS_PROCESSING_TIME_TOTAL_CPU_CYCLES, threadName),
() => (float)ProcessingCpuCycleTime.Elapsed.TotalMilliseconds, storage));
allProcessingWallClockTime.Add(
FloatValueStatistic.FindOrCreate(new StatisticName(StatisticNames.THREADS_PROCESSING_TIME_TOTAL_WALL_CLOCK, threadName),
() => (float)ProcessingWallClockTime.Elapsed.TotalMilliseconds, storage));
// numRequests
allNumProcessedRequests.Add(
FloatValueStatistic.FindOrCreate(new StatisticName(StatisticNames.THREADS_PROCESSED_REQUESTS_PER_THREAD, threadName),
() => (float)NumRequests, storage));
// aggregate stats
if (totalExecutingCpuCycleTime == null)
{
totalExecutingCpuCycleTime = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.THREADS_EXECUTION_TIME_AVERAGE_CPU_CYCLES, "AllThreads"),
() => CalculateTotalAverage(allExecutingCpuCycleTime, totalNumProcessedRequests), aggrCountersStorage);
}
if (totalExecutingWallClockTime == null)
{
totalExecutingWallClockTime = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.THREADS_EXECUTION_TIME_AVERAGE_WALL_CLOCK, "AllThreads"),
() => CalculateTotalAverage(allExecutingWallClockTime, totalNumProcessedRequests), aggrCountersStorage);
}
if (totalProcessingCpuCycleTime == null)
{
totalProcessingCpuCycleTime = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.THREADS_PROCESSING_TIME_AVERAGE_CPU_CYCLES, "AllThreads"),
() => CalculateTotalAverage(allProcessingCpuCycleTime, totalNumProcessedRequests), aggrCountersStorage);
}
if (totalProcessingWallClockTime == null)
{
totalProcessingWallClockTime = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.THREADS_PROCESSING_TIME_AVERAGE_WALL_CLOCK, "AllThreads"),
() => CalculateTotalAverage(allProcessingWallClockTime, totalNumProcessedRequests), aggrCountersStorage);
}
if (totalNumProcessedRequests == null)
{
totalNumProcessedRequests = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.THREADS_PROCESSED_REQUESTS_PER_THREAD, "AllThreads"),
() => (float)allNumProcessedRequests.Select(cs => cs.GetCurrentValue()).Sum(), aggrCountersStorage);
}
if (StatisticsCollector.PerformStageAnalysis)
{
globalStageAnalyzer.AddTracking(this);
}
}
