/// <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)); }