/// <summary>
/// Truncates the payload.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private bool TruncatePayload(PayloadBundle payloadBundle)
{
if (this._payloadTruncationStrategy == null)
{
return(true); // as far as truncation is concerned - everything is good...
}
Payload payload = payloadBundle.GetPayload();
if (this._payloadTruncationStrategy.Truncate(payload) > this._payloadTruncationStrategy.MaxPayloadSizeInBytes)
{
var exception = new ArgumentOutOfRangeException(
paramName: nameof(payload),
message: $"Payload size exceeds {this._payloadTruncationStrategy.MaxPayloadSizeInBytes} bytes limit!"
);
RollbarErrorUtility.Report(
this._rollbarLogger,
payload,
InternalRollbarError.PayloadTruncationError,
"While truncating a payload...",
exception,
payloadBundle
);
return(false);
}
return(true);
}
/// <summary>
/// Builds the payload record.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <param name="payloadQueue">The payload queue.</param>
/// <returns>PayloadRecord.</returns>
private PayloadRecord BuildPayloadRecord(PayloadBundle payloadBundle, PayloadQueue payloadQueue)
{
try
{
if (payloadBundle.Ignorable ||
payloadBundle.GetPayload() == null ||
!payloadQueue.Client.EnsureHttpContentToSend(payloadBundle)
)
{
return(null);
}
Task <string> task = payloadBundle.AsHttpContentToSend.ReadAsStringAsync();
task.Wait();
return(new PayloadRecord()
{
Timestamp = payloadBundle.GetPayload().TimeStamp,
ConfigJson = JsonUtil.SerializeAsJsonString(payloadBundle.GetPayload().Data.Notifier.Configuration),
PayloadJson = task.Result,
});
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
payloadQueue.Logger,
payloadBundle.GetPayload(),
InternalRollbarError.PersistentPayloadRecordError,
"While attempting to build persistent payload record...",
ex,
null
);
return(null);
}
}
/// <summary>
/// Builds the payload record.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <param name="payloadQueue">The payload queue.</param>
/// <returns>PayloadRecord.</returns>
private IPayloadRecord BuildPayloadRecord(PayloadBundle payloadBundle, PayloadQueue payloadQueue)
{
try
{
if (payloadBundle.Ignorable ||
payloadBundle.GetPayload() == null ||
!payloadQueue.Client.EnsureHttpContentToSend(payloadBundle)
)
{
return(null);
}
Task <string> task = payloadBundle.AsHttpContentToSend.ReadAsStringAsync();
task.Wait();
return(_storeRepository.CreatePayloadRecord(payloadBundle.GetPayload(), task.Result));
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
payloadQueue.Logger,
payloadBundle.GetPayload(),
InternalRollbarError.PersistentPayloadRecordError,
"While attempting to build persistent payload record...",
ex,
null
);
return(null);
}
}
/// <summary>
/// Obeys the payload timeout.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <param name="queue">The queue.</param>
private void ObeyPayloadTimeout(PayloadBundle payloadBundle, PayloadQueue queue)
{
if (payloadBundle.TimeoutAt.HasValue && (DateTime.Now.Add(this._sleepInterval) >= payloadBundle.TimeoutAt.Value))
{
queue.Dequeue();
}
}
/// <summary>
/// Serializes the payload as json string.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns>System.String.</returns>
private string SerializePayloadAsJsonString(PayloadBundle payloadBundle)
{
Payload payload = payloadBundle.GetPayload();
string jsonData;
try
{
jsonData = JsonConvert.SerializeObject(payload);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
payload,
InternalRollbarError.PayloadSerializationError,
"While serializing a payload...",
exception,
payloadBundle
);
return(null);
}
return(jsonData);
}
private void Report(object dataObject, ErrorLevel level, IDictionary <string, object> custom = null)
{
using (var signal = CreateSignalObject())
{
PayloadBundle payloadBundle = this._asyncLogger.EnqueueData(dataObject, level, custom, this._timeout, signal);
WaitAndCompleteReport(payloadBundle, signal);
}
}
public async Task <RollbarResponse> PostAsJsonAsync(PayloadBundle payloadBundle)
{
Assumption.AssertNotNull(payloadBundle, nameof(payloadBundle));
Payload payload = payloadBundle.GetPayload();
Assumption.AssertNotNull(payload, nameof(payload));
if (payloadBundle.AsHttpContentToSend == null)
{
if (this._payloadTruncationStrategy.Truncate(payloadBundle.GetPayload()) > this._payloadTruncationStrategy.MaxPayloadSizeInBytes)
{
throw new ArgumentOutOfRangeException(
paramName: nameof(payloadBundle),
message: $"Payload size exceeds {this._payloadTruncationStrategy.MaxPayloadSizeInBytes} bytes limit!"
);
}
var jsonData = JsonConvert.SerializeObject(payload);
jsonData = ScrubPayload(jsonData, this._config.GetFieldsToScrub());
payloadBundle.AsHttpContentToSend =
new StringContent(jsonData, Encoding.UTF8, "application/json"); //CONTENT-TYPE header
}
Assumption.AssertNotNull(payloadBundle.AsHttpContentToSend, nameof(payloadBundle.AsHttpContentToSend));
Assumption.AssertTrue(string.Equals(payload.AccessToken, this._config.AccessToken), nameof(payload.AccessToken));
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, this._payloadPostUri);
const string accessTokenHeader = "X-Rollbar-Access-Token";
request.Headers.Add(accessTokenHeader, this._config.AccessToken);
request.Content = payloadBundle.AsHttpContentToSend;
var postResponse = await this._httpClient.SendAsync(request);
RollbarResponse response = null;
if (postResponse.IsSuccessStatusCode)
{
string reply = await postResponse.Content.ReadAsStringAsync();
response = JsonConvert.DeserializeObject <RollbarResponse>(reply);
response.HttpDetails =
$"Response: {postResponse}"
+ Environment.NewLine
+ $"Request: {postResponse.RequestMessage}"
+ Environment.NewLine
;
}
else
{
postResponse.EnsureSuccessStatusCode();
}
return(response);
}
/// <summary>
/// Posts as json.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns>RollbarResponse.</returns>
public RollbarResponse PostAsJson(PayloadBundle payloadBundle)
{
Assumption.AssertNotNull(payloadBundle, nameof(payloadBundle));
var task = this.PostAsJsonAsync(payloadBundle);
task.Wait();
return(task.Result);
}
internal ILogger Enqueue(
object dataObject,
ErrorLevel level,
IDictionary <string, object> custom,
TimeSpan?timeout = null,
SemaphoreSlim signal = null
)
{
// here is the last chance to decide if we need to actually send this payload
// based on the current config settings:
if (string.IsNullOrWhiteSpace(this._config.AccessToken) ||
this._config.Enabled == false ||
(this._config.LogLevel.HasValue && level < this._config.LogLevel.Value)
)
{
// nice shortcut:
return(this);
}
DateTime?timeoutAt = null;
if (timeout.HasValue)
{
timeoutAt = DateTime.Now.Add(timeout.Value);
}
PayloadBundle payloadBundle = null;
IRollbarPackage rollbarPackage = dataObject as IRollbarPackage;
if (rollbarPackage != null)
{
if (rollbarPackage.MustApplySynchronously)
{
rollbarPackage.PackageAsRollbarData();
}
payloadBundle =
new PayloadBundle(this.Config, rollbarPackage, level, custom, timeoutAt, signal);
}
else
{
payloadBundle =
new PayloadBundle(this.Config, dataObject, level, custom, timeoutAt, signal);
}
if (payloadBundle == null)
{
//TODO: we may want to report that there is some problem with packaging...
return(this);
}
this._payloadQueue.Enqueue(payloadBundle);
return(this);
}
/// <summary>
/// Ensures the HTTP content to send.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns><c>true</c> if succeeds, <c>false</c> otherwise.</returns>
public bool EnsureHttpContentToSend(PayloadBundle payloadBundle)
{
if (payloadBundle.AsHttpContentToSend != null)
{
return(true);
}
Payload payload = payloadBundle.GetPayload();
Assumption.AssertNotNull(payload, nameof(payload));
if (!TruncatePayload(payloadBundle))
{
return(false);
}
if (!ScrubHttpMessages(payloadBundle))
{
return(false);
}
string jsonData = SerializePayloadAsJsonString(payloadBundle);
if (string.IsNullOrWhiteSpace(jsonData))
{
return(false);
}
try
{
jsonData = ScrubPayload(jsonData);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
payload,
InternalRollbarError.PayloadScrubbingError,
"While scrubbing a payload...",
exception,
payloadBundle
);
return(false);
}
payloadBundle.AsHttpContentToSend =
new StringContent(jsonData, Encoding.UTF8, "application/json"); //CONTENT-TYPE header
Assumption.AssertNotNull(payloadBundle.AsHttpContentToSend, nameof(payloadBundle.AsHttpContentToSend));
Assumption.AssertTrue(string.Equals(payload.AccessToken, this._rollbarLogger.Config.AccessToken), nameof(payload.AccessToken));
return(true);
}
public void Enqueue(PayloadBundle payload)
{
Assumption.AssertNotNull(payload, nameof(payload));
lock (this._syncLock)
{
if (this._logger.Config.ReportingQueueDepth == this._queue.Count)
{
this._queue.Dequeue();
}
this._queue.Enqueue(payload);
}
}
public PayloadBundle Peek()
{
lock (this._syncLock)
{
PayloadBundle result = null;
if (this._queue.Count > 0)
{
result = this._queue.Peek();
}
return(result);
}
}
/// <summary>
/// Processes the queues.
/// </summary>
/// <param name="tokenMetadata">The token metadata.</param>
private void ProcessQueues(AccessTokenQueuesMetadata tokenMetadata)
{
foreach (var queue in tokenMetadata.Queues)
{
if (DateTimeOffset.Now >= queue.NextDequeueTime)
{
RollbarResponse response = null;
PayloadBundle payloadBundle = Process(queue, out response);
if (payloadBundle == null || response == null)
{
continue;
}
switch (response.Error)
{
case (int)RollbarApiErrorEventArgs.RollbarError.None:
payloadBundle.Signal?.Release();
queue.Dequeue();
tokenMetadata.ResetTokenUsageDelay();
break;
case (int)RollbarApiErrorEventArgs.RollbarError.TooManyRequests:
ObeyPayloadTimeout(payloadBundle, queue);
tokenMetadata.IncrementTokenUsageDelay();
this.OnRollbarEvent(
new RollbarApiErrorEventArgs(queue.Logger, payloadBundle.GetPayload(), response)
);
return;
default:
ObeyPayloadTimeout(payloadBundle, queue);
this.OnRollbarEvent(
new RollbarApiErrorEventArgs(queue.Logger, payloadBundle.GetPayload(), response)
);
break;
}
}
}
// let's see if we can unregister any recently released queues:
var releasedQueuesToRemove = tokenMetadata.Queues.Where(q => q.IsReleased && (q.GetPayloadCount() == 0)).ToArray();
if (releasedQueuesToRemove != null && releasedQueuesToRemove.LongLength > 0)
{
foreach (var queue in releasedQueuesToRemove)
{
this.Unregister(queue);
}
}
}
private void WaitAndCompleteReport(PayloadBundle payloadBundle, SemaphoreSlim signal)
{
if (!signal.Wait(this._timeout))
{
const string exceptionMessage = "Posting a payload to the Rollbar API Service timed-out";
if (payloadBundle?.Exceptions.Count > 0)
{
throw new TimeoutException(exceptionMessage, new AggregateException(payloadBundle.Exceptions));
}
else
{
throw new TimeoutException(exceptionMessage);
}
}
}
/// <summary>
/// Processes the specified queue.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="response">The response.</param>
/// <returns>PayloadBundle.</returns>
private PayloadBundle Process(PayloadQueue queue, out RollbarResponse response)
{
response = null;
PayloadBundle payloadBundle = GetFirstTransmittableBundle(queue);
Payload payload = payloadBundle?.GetPayload();
if (payload == null) // one more sanity check before proceeding further...
{
return(null);
}
if (queue.Logger?.Config != null && !queue.Logger.Config.Transmit)
{
response = new RollbarResponse();
this.OnRollbarEvent(
new TransmissionOmittedEventArgs(queue.Logger, payload)
);
return(payloadBundle);
}
try
{
response = queue.Client.PostAsJson(payloadBundle);
}
catch (System.Exception ex)
{
this.OnRollbarEvent(
new CommunicationErrorEventArgs(queue.Logger, payload, ex, 0)
);
payloadBundle.Register(ex);
throw;
}
if (response != null)
{
this.OnRollbarEvent(
new CommunicationEventArgs(queue.Logger, payload, response)
);
}
else
{
queue.Dequeue(); //we tried our best...
payloadBundle.Register(new RollbarException(InternalRollbarError.DequeuingError, "Payload dropped!"));
}
return(payloadBundle);
}
/// <summary>
/// post as json as an asynchronous operation.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns>Task<RollbarResponse>.</returns>
public async Task <RollbarResponse> PostAsJsonAsync(PayloadBundle payloadBundle)
{
Assumption.AssertNotNull(payloadBundle, nameof(payloadBundle));
// make sure there anything meaningful to send:
if (!EnsureHttpContentToSend(payloadBundle))
{
return(null);
}
return(await PostAsJsonAsync(
this._payloadPostUri,
this._rollbarLogger.Config.AccessToken,
payloadBundle.AsHttpContentToSend
));
}
/// <summary>
/// Posts as json.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns>RollbarResponse.</returns>
public RollbarResponse PostAsJson(PayloadBundle payloadBundle)
{
Assumption.AssertNotNull(payloadBundle, nameof(payloadBundle));
// first, let's run quick Internet availability check
// to minimize potential timeout of the following JSON POST call:
if (!ConnectivityMonitor.Instance.IsConnectivityOn)
{
throw new HttpRequestException("Preliminary ConnectivityMonitor detected offline status!");
}
var task = this.PostAsJsonAsync(payloadBundle);
//task.Wait(expectedPostToApiTimeout);
task.Wait();
return(task.Result);
}
/// <summary>
/// Enqueues the specified payload.
/// </summary>
/// <param name="payload">The payload.</param>
public void Enqueue(PayloadBundle payload)
{
Assumption.AssertNotNull(payload, nameof(payload));
if (payload == null)
{
return; // no one needs to enqueue "nothing"...
}
lock (this._syncLock)
{
if (this._logger.Config.ReportingQueueDepth == this._queue.Count)
{
this._queue.Dequeue();
}
this._queue.Enqueue(payload);
}
}
public PayloadBundle Dequeue()
{
lock (this._syncLock)
{
PayloadBundle result = null;
if (this._queue.Count > 0)
{
result = this._queue.Dequeue();
TimeSpan delta = TimeSpan.FromTicks(
TimeSpan.FromMinutes(1).Ticks / this.Logger.Config.MaxReportsPerMinute
);
this.NextDequeueTime = DateTimeOffset.Now.Add(delta);
}
return(result);
}
}
/// <summary>
/// Gets the first transmittabl bundle.
/// </summary>
/// <param name="queue">The queue.</param>
/// <returns>PayloadBundle.</returns>
private PayloadBundle GetFirstTransmittableBundle(PayloadQueue queue)
{
PayloadBundle payloadBundle = null;
bool ignorableBundle = false;
do
{
payloadBundle = queue.Peek();
if (payloadBundle == null)
{
return(null); // the queue is already empty, nothing to process...
}
try
{
ignorableBundle = (payloadBundle.Ignorable || payloadBundle.GetPayload() == null);
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
null,
payloadBundle,
InternalRollbarError.DequeuingError,
"While attempting to dequeue a payload bundle...",
ex,
payloadBundle
);
ignorableBundle = true; // since something is not kosher about this bundle/payload, it is wise to ignore one...
}
if (ignorableBundle)
{
queue.Dequeue(); //throw away the ignorable...
this.OnRollbarEvent(
new PayloadDropEventArgs(queue.Logger, null, PayloadDropEventArgs.DropReason.IgnorablePayload)
);
}
}while (ignorableBundle);
return(payloadBundle);
}
/// <summary>
/// Posts as json.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns>RollbarResponse.</returns>
public RollbarResponse PostAsJson(PayloadBundle payloadBundle)
{
Assumption.AssertNotNull(payloadBundle, nameof(payloadBundle));
// first, let's run quick Internet availability check
// to minimize potential timeout of the following JSON POST call:
if (!ConnectivityMonitor.Instance.IsConnectivityOn)
{
throw new HttpRequestException("Preliminary ConnectivityMonitor detected offline status!");
}
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
var task = this.PostAsJsonAsync(payloadBundle, cancellationTokenSource.Token);
try
{
if (!task.Wait(this._expectedPostToApiTimeout))
{
cancellationTokenSource.Cancel(true);
}
return(task.Result);
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
null,
payloadBundle.AsHttpContentToSend,
InternalRollbarError.PayloadPostError,
"While PostAsJson(PayloadBundle payloadBundle)...",
ex,
payloadBundle
);
return(null);
}
}
}
/// <summary>
/// Creates the payload bundle.
/// </summary>
/// <param name="dataObject">The data object.</param>
/// <param name="level">The level.</param>
/// <param name="custom">The custom.</param>
/// <param name="timeout">The timeout.</param>
/// <param name="signal">The signal.</param>
/// <returns>PayloadBundle.</returns>
private PayloadBundle CreatePayloadBundle(
object dataObject,
ErrorLevel level,
IDictionary <string, object> custom,
TimeSpan?timeout = null,
SemaphoreSlim signal = null
)
{
DateTime?timeoutAt = null;
if (timeout.HasValue)
{
timeoutAt = DateTime.Now.Add(timeout.Value);
}
PayloadBundle payloadBundle = null;
IRollbarPackage rollbarPackage = dataObject as IRollbarPackage;
if (rollbarPackage != null)
{
if (rollbarPackage.MustApplySynchronously)
{
rollbarPackage.PackageAsRollbarData();
}
payloadBundle =
new PayloadBundle(this, rollbarPackage, level, custom, timeoutAt, signal);
}
else
{
payloadBundle =
new PayloadBundle(this, dataObject, level, custom, timeoutAt, signal);
}
return(payloadBundle);
}
/// <summary>
/// Scrubs the HTTP messages.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private bool ScrubHttpMessages(PayloadBundle payloadBundle)
{
Payload payload = payloadBundle.GetPayload();
DTOs.Request request = payload.Data.Request;
if (request?.PostBody is string requestBody)
{
if (request.Headers.TryGetValue("Content-Type", out string contentTypeHeader))
{
request.PostBody =
this.ScrubHttpMessageBodyContentString(
requestBody,
contentTypeHeader,
this._payloadScrubber.ScrubMask,
this._payloadScrubber.PayloadFieldNames,
this._payloadScrubber.HttpRequestBodyPaths);
}
}
DTOs.Response response = payload.Data.Response;
if (response?.Body is string responseBody)
{
if (response.Headers.TryGetValue("Content-Type", out string contentTypeHeader))
{
response.Body =
this.ScrubHttpMessageBodyContentString(
responseBody,
contentTypeHeader,
this._payloadScrubber.ScrubMask,
this._payloadScrubber.PayloadFieldNames,
this._payloadScrubber.HttpResponseBodyPaths);
}
}
return(true);
}
/// <summary>
/// Processes the queues.
/// </summary>
/// <param name="tokenMetadata">The token metadata.</param>
private void ProcessQueues(AccessTokenQueuesMetadata tokenMetadata)
{
// let's see if we can unregister any recently released queues:
var releasedQueuesToRemove = tokenMetadata.Queues.Where(q => q.IsReleased && (q.GetPayloadCount() == 0)).ToArray();
if (releasedQueuesToRemove != null && releasedQueuesToRemove.LongLength > 0)
{
foreach (var queue in releasedQueuesToRemove)
{
this.Unregister(queue);
}
}
// process the access token's queues:
foreach (var queue in tokenMetadata.Queues)
{
if (DateTimeOffset.Now < queue.NextDequeueTime)
{
// this means the queue overrides its reporting rate limit via its configuration settings
// let's observe its settings and skip processing:
continue;
}
if (tokenMetadata.IsTransmissionSuspended && DateTimeOffset.Now < tokenMetadata.NextTimeTokenUsage)
{
// the token is suspended and the next usage time is not reached,
// let's flush the token queues (we are not allowed to transmit anyway)
// and quit processing this token's queues this time (until next processing iteration):
foreach (var tokenQueue in tokenMetadata.Queues)
{
foreach (var flushedBundle in tokenQueue.Flush())
{
this.OnRollbarEvent(
new PayloadDropEventArgs(
queue.Logger,
flushedBundle.GetPayload(),
PayloadDropEventArgs.DropReason.TokenSuspension
)
);
}
}
return;
}
PayloadBundle payloadBundle = null;
RollbarResponse response = null;
try
{
payloadBundle = Process(queue, out response);
}
catch (AggregateException aggregateException)
{
if (aggregateException.InnerExceptions.Any(e => e is HttpRequestException))
{
this.Persist(queue);
continue;
}
else
{
var bundle = queue.Dequeue();
this.OnRollbarEvent(
new PayloadDropEventArgs(queue.Logger, bundle.GetPayload(), PayloadDropEventArgs.DropReason.InvalidPayload)
);
queue.Dequeue();
throw;
}
}
catch (System.Exception ex)
{
this.Persist(queue);
continue;
}
if (payloadBundle != null && response == null)
{
var bundle = queue.Dequeue();
this.OnRollbarEvent(
new PayloadDropEventArgs(queue.Logger, bundle.GetPayload(), PayloadDropEventArgs.DropReason.AllTransmissionRetriesFailed)
);
}
if (payloadBundle == null || response == null)
{
continue;
}
tokenMetadata.UpdateNextTimeTokenUsage(response.RollbarRateLimit);
switch (response.Error)
{
case (int)RollbarApiErrorEventArgs.RollbarError.None:
payloadBundle.Signal?.Release();
queue.Dequeue();
break;
case (int)RollbarApiErrorEventArgs.RollbarError.TooManyRequests:
ObeyPayloadTimeout(payloadBundle, queue);
this.OnRollbarEvent(
new RollbarApiErrorEventArgs(queue.Logger, payloadBundle.GetPayload(), response)
);
return;
default:
ObeyPayloadTimeout(payloadBundle, queue);
this.OnRollbarEvent(
new RollbarApiErrorEventArgs(queue.Logger, payloadBundle.GetPayload(), response)
);
break;
}
}
}
/// <summary>
/// Enqueues the data.
/// </summary>
/// <param name="dataObject">The data object.</param>
/// <param name="level">The level.</param>
/// <param name="custom">The custom.</param>
/// <param name="timeout">The timeout.</param>
/// <param name="signal">The signal.</param>
/// <returns>PayloadBundle.</returns>
internal PayloadBundle EnqueueData(
object dataObject,
ErrorLevel level,
IDictionary <string, object> custom,
TimeSpan?timeout = null,
SemaphoreSlim signal = null
)
{
// here is the last chance to decide if we need to actually send this payload
// based on the current config settings and rate-limit conditions:
if (string.IsNullOrWhiteSpace(this._config.AccessToken) ||
this._config.Enabled == false ||
(this._config.LogLevel.HasValue && level < this._config.LogLevel.Value) ||
((this._payloadQueue.AccessTokenQueuesMetadata != null) && this._payloadQueue.AccessTokenQueuesMetadata.IsTransmissionSuspended)
)
{
// nice shortcut:
return(null);
}
if (this._config.RethrowExceptionsAfterReporting)
{
System.Exception exception = dataObject as System.Exception;
if (exception == null)
{
if (dataObject is Data data && data.Body != null)
{
exception = data.Body.OriginalException;
}
}
if (exception != null)
{
try
{
// Here we need to create another logger instance with similar config but configured not to re-throw.
// This would prevent infinite recursive calls (in case if we used this instance or any re-throwing instance).
// Because we will be re-throwing the exception after reporting, let's report it fully-synchronously.
// This logic is on a heavy side. But, fortunately, RethrowExceptionsAfterReporting is intended to be
// a development time option:
var config = new RollbarConfig();
config.Reconfigure(this._config);
config.RethrowExceptionsAfterReporting = false;
using (var rollbar = RollbarFactory.CreateNew(config))
{
rollbar.AsBlockingLogger(TimeSpan.FromSeconds(1)).Log(level, dataObject, custom);
}
}
catch
{
// In case there was a TimeoutException (or any un-expected exception),
// there is nothing we can do here.
// We tried our best...
}
finally
{
if (exception is AggregateException aggregateException)
{
exception = aggregateException.Flatten();
ExceptionDispatchInfo.Capture(
exception.InnerException).Throw();
}
else
{
ExceptionDispatchInfo.Capture(exception).Throw();
}
}
return(null);
}
}
PayloadBundle payloadBundle = null;
try
{
payloadBundle = CreatePayloadBundle(dataObject, level, custom, timeout, signal);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this,
dataObject,
InternalRollbarError.BundlingError,
null,
exception,
payloadBundle
);
return(null);
}
try
{
this._payloadQueue.Enqueue(payloadBundle);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this,
dataObject,
InternalRollbarError.EnqueuingError,
null,
exception,
payloadBundle
);
}
return(payloadBundle);
}
private PayloadBundle Process(PayloadQueue queue, out RollbarResponse response)
{
response = null;
PayloadBundle payloadBundle = queue.Peek();
while (payloadBundle != null && (payloadBundle.Ignorable || payloadBundle.GetPayload() == null))
{
queue.Dequeue(); //throw away the useless one...
payloadBundle = queue.Peek(); //try next...
}
if (payloadBundle == null)
{
return(null); //no bundles to process...
}
Payload payload = payloadBundle.GetPayload();
if (payload == null)
{
return(null);
}
int retries = this._totalRetries;
while (retries > 0)
{
try
{
response = queue.Client.PostAsJson(payloadBundle);
}
catch (WebException ex)
{
retries--;
this.OnRollbarEvent(
new CommunicationErrorEventArgs(queue.Logger, payload, ex, retries)
);
continue;
}
catch (ArgumentNullException ex)
{
retries = 0;
this.OnRollbarEvent(
new CommunicationErrorEventArgs(queue.Logger, payload, ex, retries)
);
continue;
}
catch (System.Exception ex)
{
retries = 0;
this.OnRollbarEvent(
new CommunicationErrorEventArgs(queue.Logger, payload, ex, retries)
);
continue;
}
retries = 0;
}
if (response != null)
{
this.OnRollbarEvent(
new CommunicationEventArgs(queue.Logger, payload, response)
);
}
return(payloadBundle);
}
