/// <summary>
/// Tries the posting.
/// </summary>
/// <param name="payloadRecord">The payload record.</param>
/// <returns>RollbarResponse.</returns>
private RollbarResponse TryPosting(PayloadRecord payloadRecord)
{
//Payload payload = JsonConvert.DeserializeObject<Payload>(payloadRecord.PayloadJson);
//IRollbarConfig config = payload.Data.Notifier.Configuration;
IRollbarConfig config = JsonConvert.DeserializeObject <RollbarConfig>(payloadRecord.ConfigJson);
RollbarClient rollbarClient = new RollbarClient(config);
try
{
RollbarResponse response =
rollbarClient.PostAsJson(config.EndPoint, config.AccessToken, payloadRecord.PayloadJson);
return(response);
}
catch (System.Exception ex)
{
this.OnRollbarEvent(
new CommunicationErrorEventArgs(null, payloadRecord.PayloadJson, ex, 0)
);
RollbarErrorUtility.Report(
null,
payloadRecord,
InternalRollbarError.PersistentPayloadRecordRepostError,
"While trying to report a stored payload...",
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>
/// 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>
/// 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>
/// 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);
}
/// <summary>
/// Persists the specified payload queue.
/// </summary>
/// <param name="payloadQueue">The payload queue.</param>
private void Persist(PayloadQueue payloadQueue)
{
var items = payloadQueue.GetItemsToPersist();
if (items == null || items.Length == 0)
{
return;
}
string endPoint = payloadQueue.Logger.Config.EndPoint;
string accessToken = payloadQueue.AccessTokenQueuesMetadata.AccessToken;
Destination destination = this._storeContext.Destinations.SingleOrDefault(d =>
d.Endpoint == endPoint &&
d.AccessToken == accessToken
);
if (destination == null)
{
destination = new Destination()
{
Endpoint = endPoint, AccessToken = accessToken,
};
this._storeContext.Destinations.Add(destination);
}
foreach (var item in items)
{
PayloadRecord payloadRecord = this.BuildPayloadRecord(item, payloadQueue);
if (payloadRecord != null)
{
destination.PayloadRecords.Add(payloadRecord);
}
}
try
{
this._storeContext.SaveChanges();
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
payloadQueue.Logger,
items.Select(i => i.GetPayload()),
InternalRollbarError.PersistentStoreContextError,
"While attempting to save persistent store context...",
ex,
null
);
}
foreach (var item in items)
{
item.Signal?.Release();
}
}
/// <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);
}
private void CheckConnectivityStatus(object state)
{
try
{
DoCheckConnectivityStatus();
}
catch (Exception ex)
{
RollbarErrorUtility.Report(null, null, InternalRollbarError.ConnectivityMonitorError, null, ex, null);
}
}
/// <summary>
/// Keeps the processing all queues.
/// </summary>
/// <param name="data">The data.</param>
private void KeepProcessingAllQueues(object data)
{
CancellationToken cancellationToken = (CancellationToken)data;
while (!cancellationToken.IsCancellationRequested)
{
try
{
lock (this._syncLock)
{
ProcessAllQueuesOnce();
}
ProcessPersistentStoreOnce();
}
#pragma warning disable CS0168 // Variable is declared but never used
catch (System.Threading.ThreadAbortException tae)
{
return;
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
null,
null,
InternalRollbarError.QueueControllerError,
"While KeepProcessingAllQueues()...",
ex,
null
);
//TODO: do we want to direct the exception
// to some kind of Rollbar notifier maintenance "access token"?
}
#pragma warning restore CS0168 // Variable is declared but never used
if (cancellationToken.IsCancellationRequested)
{
break;
}
Thread.Sleep(this._sleepInterval);
}
CompleteProcessing();
}
/// <summary>
/// Persists the specified payload queue.
/// </summary>
/// <param name="payloadQueue">The payload queue.</param>
private void Persist(PayloadQueue payloadQueue)
{
if (!payloadQueue.Logger.Config.EnableLocalPayloadStore)
{
return;
}
var items = payloadQueue.GetItemsToPersist();
if (items == null || items.Length == 0)
{
return;
}
string endPoint = payloadQueue.Logger.Config.EndPoint;
string accessToken = payloadQueue.AccessTokenQueuesMetadata.AccessToken;
var payloads = new List <IPayloadRecord>();
foreach (var item in items)
{
payloads.Add(this.BuildPayloadRecord(item, payloadQueue));
}
try
{
this._storeRepository.SavePayloads(endPoint, accessToken, payloads);
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
payloadQueue.Logger,
items.Select(i => i.GetPayload()),
InternalRollbarError.PersistentStoreContextError,
"While attempting to save persistent store context...",
ex,
null
);
}
foreach (var item in items)
{
item.Signal?.Release();
}
}
/// <summary>
/// Enqueues the specified data object.
/// </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>ILogger.</returns>
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);
}
PayloadBundle payloadBundle;
try
{
payloadBundle = CreatePayloadBundle(dataObject, level, custom, timeout, signal);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(this, dataObject, InternalRollbarError.BundlingError, null, exception);
return(this);
}
try
{
this._payloadQueue.Enqueue(payloadBundle);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(this, dataObject, InternalRollbarError.EnqueuingError, null, exception);
}
return(this);
}
/// <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>
/// Checks the connectivity status.
/// </summary>
/// <param name="state">The state.</param>
private void CheckConnectivityStatus(object state)
{
try
{
DoCheckConnectivityStatus();
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
{
RollbarErrorUtility.Report(
null,
null,
InternalRollbarError.ConnectivityMonitorError,
null,
ex,
null
);
}
#pragma warning restore CA1031 // Do not catch general exception types
}
/// <summary>
/// Posts as json.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="jsonContent">Content of the json.</param>
/// <returns>RollbarResponse.</returns>
public RollbarResponse PostAsJson(string accessToken, string jsonContent)
{
Assumption.AssertNotNullOrWhiteSpace(accessToken, nameof(accessToken));
Assumption.AssertNotNullOrWhiteSpace(jsonContent, nameof(jsonContent));
// 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(accessToken, jsonContent, cancellationTokenSource.Token);
try
{
if (!task.Wait(this._expectedPostToApiTimeout))
{
cancellationTokenSource.Cancel(true);
}
return(task.Result);
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
null,
jsonContent,
InternalRollbarError.PayloadPostError,
"While PostAsJson((string destinationUri, string accessToken, string jsonContent)...",
ex,
null
);
return(null);
}
}
}
/// <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;
Payload payload = 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)
);
}
else
{
payload = payloadBundle.GetPayload();
}
}while (ignorableBundle);
if (payloadBundle == null || 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);
}
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)
);
payloadBundle.Register(ex);
Thread.Sleep(this._sleepInterval); // wait a bit before we retry it...
continue;
}
catch (ArgumentNullException ex)
{
retries = 0;
this.OnRollbarEvent(
new CommunicationErrorEventArgs(queue.Logger, payload, ex, retries)
);
payloadBundle.Register(ex);
continue;
}
catch (System.Exception ex)
{
retries = 0;
this.OnRollbarEvent(
new CommunicationErrorEventArgs(queue.Logger, payload, ex, retries)
);
payloadBundle.Register(ex);
continue;
}
retries = 0;
}
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>
/// 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;
Payload payload = 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
);
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...
}
else
{
payload = payloadBundle.GetPayload();
}
}while (ignorableBundle);
if (payloadBundle == null || payload == null) // one more sanity check before proceeding further...
{
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);
}
/// <summary>
/// Gets the payload.
/// </summary>
/// <returns>Payload.</returns>
public Payload GetPayload()
{
if (this._payload == null)
{
Data data = this.GetPayloadData();
if (data != null)
{
data.Level = this._level;
//update the data timestamp from the data creation timestamp to the passed
//object-to-log capture timestamp:
data.Timestamp = DateTimeUtil.ConvertToUnixTimestampInSeconds(this._timeStamp);
this._payload = new Payload(this._rollbarLogger.Config.AccessToken, data);
try // payload check-ignore:
{
if (this._rollbarLogger.Config.CheckIgnore != null &&
this._rollbarLogger.Config.CheckIgnore.Invoke(this._payload)
)
{
this._ignorable = true;
return(this._payload); //shortcut...
}
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadCheckIgnoreError,
"While check-ignoring a payload...",
exception
);
}
this._ignorable = false;
try // payload transformation:
{
this._rollbarLogger.Config.Transform?.Invoke(this._payload);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadTransformError,
"While transforming a payload...",
exception
);
}
try // payload truncation:
{
this._rollbarLogger.Config.Truncate?.Invoke(this._payload);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadTruncationError,
"While truncating a payload...",
exception
);
}
try
{
this._payload.Validate();
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadValidationError,
"While validating a payload...",
exception
);
}
}
}
return(this._payload);
}
/// <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.RollbarDestinationOptions.AccessToken) ||
!this._config.RollbarDeveloperOptions.Enabled ||
(level < this._config.RollbarDeveloperOptions.LogLevel)
)
{
// nice shortcut:
return(null);
}
if (this._config.RollbarDeveloperOptions.RethrowExceptionsAfterReporting)
{
System.Exception?exception = dataObject as System.Exception;
if (exception == null &&
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 RollbarLoggerConfig();
config.Reconfigure(this._config);
config.RollbarDeveloperOptions.RethrowExceptionsAfterReporting = false;
using var rollbar = RollbarFactory.CreateNew(config);
rollbar.AsBlockingLogger(TimeSpan.FromSeconds(1)).Log(level, dataObject, custom);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch
{
// In case there was a TimeoutException (or any un-expected exception),
// there is nothing we can do here.
// We tried our best...
}
#pragma warning restore CA1031 // Do not catch general exception types
finally
{
if (exception is AggregateException aggregateException)
{
exception = aggregateException.Flatten();
}
ExceptionDispatchInfo.Capture(exception).Throw();
}
return(null);
}
}
PayloadBundle?payloadBundle = null;
try
{
payloadBundle = CreatePayloadBundle(dataObject, level, custom, timeout, signal);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this,
dataObject,
InternalRollbarError.BundlingError,
null,
exception,
payloadBundle
);
return(null);
}
#pragma warning restore CA1031 // Do not catch general exception types
try
{
_ = this._rollbarClient.PostAsJsonAsync(payloadBundle);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this,
dataObject,
InternalRollbarError.EnqueuingError,
null,
exception,
payloadBundle
);
}
#pragma warning restore CA1031 // Do not catch general exception types
return(payloadBundle);
}
/// <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);
}
/// <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));
Payload payload = payloadBundle.GetPayload();
Assumption.AssertNotNull(payload, nameof(payload));
if (payloadBundle.AsHttpContentToSend == null)
{
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
);
}
string jsonData = null;
try
{
jsonData = JsonConvert.SerializeObject(payload);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
payload,
InternalRollbarError.PayloadSerializationError,
"While serializing a payload...",
exception,
payloadBundle
);
return(null);
}
try
{
jsonData = ScrubPayload(jsonData, this._rollbarLogger.Config.GetFieldsToScrub());
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
payload,
InternalRollbarError.PayloadScrubbingError,
"While scrubbing a payload...",
exception,
payloadBundle
);
return(null);
}
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));
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, this._payloadPostUri);
const string accessTokenHeader = "X-Rollbar-Access-Token";
request.Headers.Add(accessTokenHeader, this._rollbarLogger.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.RollbarRateLimit =
new RollbarRateLimit(postResponse.Headers);
response.HttpDetails =
$"Response: {postResponse}"
+ Environment.NewLine
+ $"Request: {postResponse.RequestMessage}"
+ Environment.NewLine
;
}
else
{
postResponse.EnsureSuccessStatusCode();
}
return(response);
}