/// <summary>
/// Calculates and returns a summary of each of the stored statistic types.
/// </summary>
public void GetSummary(out List <OperationRollup> operations, out List <OperationRollup> commands, out List <TaskStats> runningTasks, out List <TaskStats> completedTasks)
{
operations = new List <OperationRollup>();
commands = new List <OperationRollup>();
runningTasks = new List <TaskStats>();
completedTasks = new List <TaskStats>();
try
{
lock (_rollupLock)
{
foreach (string name in _operationRollups.Keys)
{
OperationRollup r = RollupRollups(_operationRollups[name], _lastSwap);
if (r != null)
{
operations.Add(r);
}
}
foreach (string name in _commandRollups.Keys)
{
OperationRollup r = RollupRollups(_commandRollups[name], _lastSwap);
if (r != null)
{
commands.Add(r);
}
}
}
lock (_taskLock)
{
DateTime now = DateTime.Now;
DateTime sixHoursAgo = now.Subtract(TimeSpan.FromHours(6));
while ((_completedTasks.Count > 0) && (_completedTasks[0].EndTime < sixHoursAgo))
{
_completedTasks.RemoveAt(0);
}
foreach (Guid id in _runningTasks.Keys)
{
TaskStats t = _runningTasks[id].Clone();
runningTasks.Add(t);
}
foreach (TaskStats tx in _completedTasks)
{
TaskStats t = tx.Clone();
completedTasks.Add(t);
}
}
operations = operations.OrderBy(x => x.Name).ToList();
commands = commands.OrderBy(x => x.Name).ToList();
runningTasks = runningTasks.OrderBy(x => x.StartTime).ToList();
completedTasks = completedTasks.OrderBy(x => x.StartTime).ToList();
}
catch (Exception ex)
{
if (_errorHandler != null)
{
_errorHandler.LogError(ex);
}
}
}
/// <summary>
/// Combines a list of rollup objects into a single rollup object.
/// </summary>
private OperationRollup RollupRollups(List <OperationRollup> rollups, DateTime endTime)
{
try
{
if (rollups.Count == 0)
{
return(null);
}
long count = 0;
long elapsedSum = 0;
long elapsedMin = Int64.MaxValue;
long elapsedMax = Int64.MinValue;
DateTime startTime = DateTime.MaxValue;
foreach (OperationRollup r in rollups)
{
count += r.Count;
elapsedSum += r.ElapsedSum;
if (r.ElapsedMin < elapsedMin)
{
elapsedMin = r.ElapsedMin;
}
if (r.ElapsedMax > elapsedMax)
{
elapsedMax = r.ElapsedMax;
}
if (r.StartTime < startTime)
{
startTime = r.StartTime;
}
}
OperationRollup rx = new OperationRollup(rollups[0].Name, count, elapsedSum, elapsedMin, elapsedMax, rollups[0].IsPing, startTime, endTime);
return(rx);
}
catch (Exception ex)
{
if (_errorHandler != null)
{
_errorHandler.LogError(ex);
}
}
return(null);
}
/// <summary>
/// Rolls up the six second queue into a single object for each unique command or operation.
/// Logs each to the AWS CloudWatch service, then appends each to the six hour rolling time window.
/// Removes items from the six hour window if they have expired.
/// </summary>
private void SwapAndRollup(ref Dictionary <string, List <OperationStats> > queue, ref Dictionary <string, List <OperationRollup> > rollups, DateTime now, DateTime sixHoursAgo)
{
try
{
Dictionary <string, List <OperationStats> > swap;
lock (_queueLock)
{
swap = queue;
queue = new Dictionary <string, List <OperationStats> >();
}
var rs = new List <OperationRollup>();
foreach (List <OperationStats> ss in swap.Values)
{
OperationRollup r = RollupStats(ss, _lastSwap, now);
if (r != null)
{
rs.Add(r);
}
}
lock (_rollupLock)
{
foreach (OperationRollup r in rs)
{
if (!rollups.ContainsKey(r.Name))
{
rollups.Add(r.Name, new List <OperationRollup>());
}
rollups[r.Name].Add(r);
}
foreach (string name in rollups.Keys)
{
while ((rollups[name].Count > 0) && (rollups[name][0].StartTime < sixHoursAgo))
{
rollups[name].RemoveAt(0);
}
}
}
}
catch (Exception ex)
{
if (_errorHandler != null)
{
_errorHandler.LogError(ex);
}
}
}
