Dashboard.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="Dashboard.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Data portal dashboard</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
 
namespace Csla.Server.Dashboard
{
  public class Dashboard : IDashboard
  {
    private readonly object _syncLock = new object();
    private ConcurrentQueue<InterceptArgs> _initializeQueue = new ConcurrentQueue<InterceptArgs>();
    private ConcurrentQueue<InterceptArgs> _completeQueue = new ConcurrentQueue<InterceptArgs>();
    private readonly Timer _timerInitialize;
    private readonly Timer _timerComplete;
    private ConcurrentQueue<Activity> _recentActivity = new ConcurrentQueue<Activity>();
    private const int _timerDueTime = 50;
    private const int _timerPeriod = 500;
 
    public Dashboard()
    {
      _timerInitialize = new Timer(ProcessInitializeQueue, null, _timerDueTime, _timerPeriod);
      _timerComplete = new Timer(ProcessCompleteQueue, null, _timerDueTime, _timerPeriod);
      FirstCall = DateTimeOffset.Now;
    }
 
    public int RecentActivityCount { get; set; } = 100;
 
    private void ProcessCompleteQueue(object state)
    {
      if (_completeQueue.IsEmpty)
        return;
 
      _timerComplete.Change(Timeout.Infinite, Timeout.Infinite);
      try
      {
        while (_completeQueue.TryDequeue(out InterceptArgs result))
        {
          if (result.Exception != null)
            Interlocked.Add(ref _failedCalls, 1);
          else
            Interlocked.Add(ref _completedCalls, 1);
          _recentActivity.Enqueue(new Activity(result));
        }
        // trim list to most recent items
        while (_recentActivity.Count > RecentActivityCount)
          _recentActivity.TryDequeue(out Activity discard);
      }
      finally
      {
        _timerComplete.Change(_timerDueTime, _timerPeriod);
      }
    }
 
    private void ProcessInitializeQueue(object state)
    {
      if (_initializeQueue.IsEmpty)
        return;
 
      _timerInitialize.Change(Timeout.Infinite, Timeout.Infinite);
      try
      {
        while (_initializeQueue.TryDequeue(out InterceptArgs result))
        {
          Interlocked.Add(ref _totalCalls, 1);
        }
      }
      finally
      {
        _timerInitialize.Change(_timerDueTime, _timerPeriod);
      }
    }
 
    public DateTimeOffset FirstCall { get; private set; }
    public DateTimeOffset LastCall { get; private set; }
    private long _totalCalls;
    public long TotalCalls
    {
      get { return Interlocked.Read(ref _totalCalls); }
    }
 
    private long _completedCalls;
    public long CompletedCalls
    {
      get { return Interlocked.Read(ref _completedCalls); }
    }
 
    private long _failedCalls;
    public long FailedCalls
    {
      get { return Interlocked.Read(ref _failedCalls); }
    }
 
    public List<Activity> GetRecentActivity()
    {
      return _recentActivity.ToList();
    }
 
    void IDashboard.InitializeCall(InterceptArgs e)
    {
      LastCall = DateTimeOffset.Now;
      _initializeQueue.Enqueue(e);
    }
 
    void IDashboard.CompleteCall(InterceptArgs e)
    {
      _completeQueue.Enqueue(e);
    }
 
    public void Dispose()
    {
      _timerComplete.Dispose();
      _timerInitialize.Dispose();
    }
  }
}