private void AddToBuffer(TraceWrapper trace)
{
// le lock va empiler les appelants (mais c'est ce que l'on souhaite)
lock (_key)
{
if (_buffer.IsAddingCompleted || _buffer.TryAdd(trace))
{
return;
}
}
// l'appel temporisé n'est pas locké et gère donc le catch des ajout alors que la collection a été marquée comme terminée (CompleteAdding = true)
// ReSharper disable InconsistentlySynchronizedField => pas de lock pour ce cas car on ne souhaite pas bloquer le completeAdding aussi.
try
{
// sinon, on envoie un évènement pour signaler que l'ajout n'a pu être fait immédiatement et on retente avec un temps d'attente
RaiseSentTraces(ListenerHelpers.GetExceptionArray($"impossible d'ajouter immédiatement le message {trace.Message}: buffer plein : {_buffer.Count}"));
if (!_buffer.TryAdd(trace, _maxTimeoutForFullBuffer))
{
// Dans le cas où l'on ne peut pas insérer une trace à la fin du timeout, on lance une exception
throw new ArgumentException(
$@"ERROR: Max timeout for trace insertion in buffer reached ({_maxTimeoutForFullBuffer.TotalMilliseconds} ms)");
}
}
catch (InvalidOperationException e)
{
RaiseSentTraces(ListenerHelpers.GetExceptionArray($"InvalidOperationException (cas du buffer où CompleteAdding = true par exemple) dans les traces. {e}"));
}
// ReSharper restore InconsistentlySynchronizedField
}
/// <inheritdoc />
/// <summary>
/// Construit un traceur avec un temps de flush maximum et une taille de page
/// </summary>
/// <param name="timeForFlush">la plage maximum de temps à partir duquel on va vider la pile malgré tt</param>
/// <param name="poolingPageSize">la taille des page émises par le traceur au maximum (elles peuvent être plus petites)</param>
public TraceListenerSync(TimeSpan timeForFlush, int poolingPageSize)
{
ListenerHelpers.CheckEntryValuesAndThrowExceptionIfFailed(timeForFlush, poolingPageSize);
_poolingPageSize = poolingPageSize;
// on défini la taille maximum que pourra atteindre le buffer avant que les appels de trace soient
// bloquant (cas de remplissage extrèment plus rapide que le vidage via la tache Dequeue() == hautement improbable)
//=> cette taille est définie à la taille d'une page == on stocke au maximum une page dans le buffer
_buffer = new BlockingCollection <TraceWrapper>(poolingPageSize);
// Configure le timer gérant le temps de flush maximum des pages
_timer = new Timer(timeForFlush.TotalMilliseconds)
{
AutoReset = false
};
_timer.Elapsed += OnTimerElapsed;
_timer.Start();
// démarre la pile d'analyse:
_dequeueTask = Task.Run(() => Dequeue());
}
/// <summary>
/// En cas d'exception, on trace un message vers l'extérieur pour signaler le problème
/// </summary>
/// <param name="e">l'exception</param>
private void RaiseException(Exception e)
{
RaiseSentTraces(ListenerHelpers.GetExceptionArray($"EXCEPTION IN TRACER: UNABLE TO FORMAT {e}"));
}
