/// <summary>
/// Création d'un sous-processus.
/// </summary>
/// <param name="subProcessName">Nom du sous processus.</param>
/// <returns>Sous-processus.</returns>
internal CounterProcess CreateSubProcess(string subProcessName)
{
CounterProcess child = new CounterProcess(subProcessName);
child._parent = this;
return(child);
}
/// <summary>
/// Ajout d'un processus clôtûré à la base.
/// </summary>
/// <param name="process">Processus obligatoirement clôtûré.</param>
/// <returns>Retourne la durée du processus.</returns>
long IWritableHyperCube.AddProcess(CounterProcess process)
{
string axis = "global";
ObtainCounters(axis).AddProcess(process);
axis = process.Name;
ObtainCounters(axis).AddProcess(process);
return(process.Duration);
}
/// <summary>
/// Libère les ressources de la classe.
/// </summary>
public void Dispose()
{
if (_threadStarted)
{
_resetEvent.Set();
_storageThread.Join();
}
_resetEvent.Close();
_instance = null;
_counterProcess = null;
}
/// <summary>
/// Ajoute une valeur.
/// </summary>
/// <param name="process">Processus.</param>
/// <param name="name">Nom.</param>
internal void AddValue(CounterProcess process, string name)
{
long processDuration = process.Duration;
this.AddValue(processDuration, name);
// Incrément
_hitsCounts50 += processDuration <= 50 ? 1 : 0;
_hitsCounts100 += processDuration <= 100 ? 1 : 0;
_hitsCounts200 += processDuration <= 200 ? 1 : 0;
_hitsCounts500 += processDuration <= 500 ? 1 : 0;
_hitsCounts1000 += processDuration <= 1000 ? 1 : 0;
_hitsCounts2000 += processDuration <= 2000 ? 1 : 0;
_hitsCounts5000 += processDuration <= 5000 ? 1 : 0;
_hitsCounts10000 += processDuration <= 10000 ? 1 : 0;
// Sommes
_subProcessTimes += process.SubProcessesDuration;
}
/// <summary>
/// Ajoute une nouvelle valeur.
/// </summary>
/// <param name="process">Processus.</param>
internal void AddValue(CounterProcess process)
{
this.IsModified = true;
string info;
if ("global".Equals(_key.Axis))
{
info = process.Name;
}
else
{
info = Convert.ToString(process.Date, DateFormatSecond);
}
_lastMilliSeconds = process.Date.Ticks / 10000;
if (_firstMilliSeconds == -1)
{
_firstMilliSeconds = _lastMilliSeconds;
}
_elapsedTimeCounter.AddValue(process, info);
if (_key.Level.IsExtended)
{
Dictionary <string, long> counters = process.Counters;
foreach (string code in counters.Keys)
{
CounterHit counter;
lock (_extendedMap) {
if (!_extendedMap.TryGetValue(code, out counter))
{
counter = new CounterHit(this);
_extendedMap.Add(code, counter);
}
}
counter.AddValue(counters[code], info);
}
}
}
/// <summary>
/// Ajoute une valeur au store.
/// </summary>
/// <param name="process">Processus.</param>
internal void AddValue(CounterProcess process)
{
CubeKey key = new CubeKey(process.Date, _axis, _level);
lock (this) {
Cube cube = GetCube(key);
if (cube == null)
{
cube = new Cube(key, _databaseName);
_datas.Add(key, cube);
_keyList.AddLast(key);
if (_datas.Count > _maxValueCount)
{
CubeKey firstKey = _keyList.First.Value;
_keyList.RemoveFirst();
_datas.Remove(firstKey);
}
}
cube.AddValue(process);
}
}
/// <summary>
/// Démarre un processus.
/// </summary>
/// <param name="processName">Nom du processus.</param>
public void StartProcess(string processName)
{
if (!IsEnabled && !IsSummaryEnabled)
{
return;
}
if (processName == null)
{
throw new ArgumentNullException("processName");
}
HttpContext context = HttpContext.Current;
if (context == null)
{
if (_counterProcess == null)
{
_counterProcess = new CounterProcess(processName);
}
else
{
_counterProcess = _counterProcess.CreateSubProcess(processName);
}
}
else
{
CounterProcess counterProcess = context.Items[ItemProcessCounter] as CounterProcess;
if (counterProcess == null)
{
context.Items[ItemProcessCounter] = new CounterProcess(processName);
}
else
{
context.Items[ItemProcessCounter] = counterProcess.CreateSubProcess(processName);
}
}
}
/// <summary>
/// On termine l'enristrement du process et on l'ajoute à la base de données.
/// </summary>
/// <param name="dataBaseName">Nom de la base de données.</param>
/// <returns>Retourne la durée du processus.</returns>
public long StopProcess(string dataBaseName)
{
if (string.IsNullOrEmpty(dataBaseName))
{
throw new ArgumentNullException("dataBaseName");
}
if (!IsEnabled && !IsSummaryEnabled)
{
return(0);
}
CounterProcess counterProcess;
HttpContext context = HttpContext.Current;
if (context == null)
{
counterProcess = _counterProcess;
}
else
{
counterProcess = context.Items[ItemProcessCounter] as CounterProcess;
}
// On agrège tous les compteurs
if (counterProcess == null)
{
return(0);
}
long duration;
if (IsSummaryEnabled)
{
counterProcess.Close();
duration = counterProcess.Duration;
lock (_summaryMap) {
Tuple <int, long> data;
if (_summaryMap.TryGetValue(counterProcess.Name, out data))
{
_summaryMap[counterProcess.Name] = new Tuple <int, long>(data.Item1 + 1, data.Item2 + duration);
}
else
{
_summaryMap[counterProcess.Name] = new Tuple <int, long>(1, duration);
}
}
}
else
{
CounterDataBase counterDataBase = GetDataBase(dataBaseName);
duration = counterDataBase.AddProcess(counterProcess);
}
// On ferme les compteurs
if (context == null)
{
_counterProcess = counterProcess.Parent;
}
else
{
context.Items[ItemProcessCounter] = counterProcess.Parent;
}
return(duration);
}
/// <summary>
/// Ajoute un processus au compteur.
/// </summary>
/// <param name="process">Processus.</param>
internal void AddProcess(CounterProcess process)
{
_minuteGrapheur.AddValue(process);
_heureGrapheur.AddValue(process);
}
/// <summary>
/// Ajout d'un processus à la base.
/// </summary>
/// <param name="process">Processus.</param>
/// <returns>Returne la durée du processus.</returns>
internal long AddProcess(CounterProcess process)
{
process.Close();
return(_hyperCube.AddProcess(process));
}
