/// <summary>
/// Serializes the payload as json string.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns>System.Nullable<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>
/// Keeps the processing all queues.
/// </summary>
/// <param name="data">The data.</param>
private void KeepProcessingAllQueues(object?data)
{
if (data == null)
{
RollbarErrorUtility.Report(
null,
null,
InternalRollbarError.QueueControllerError,
"While KeepProcessingAllQueues()...",
null,
null
);
return;
}
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
);
//NOTE: 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)
if (this._storeRepository == null)
{
return;
}
var items = payloadQueue.GetItemsToPersist();
if (items == null || items.Length == 0)
{
return;
}
string?endPoint = payloadQueue.Logger.Config.RollbarDestinationOptions.EndPoint;
string?accessToken = payloadQueue.AccessTokenQueuesMetadata?.AccessToken;
if (string.IsNullOrWhiteSpace(endPoint) || string.IsNullOrWhiteSpace(accessToken))
{
return;
}
var payloads = new List <IPayloadRecord>();
foreach (var item in items)
{
var payloadRecord = this.BuildPayloadRecord(item, payloadQueue);
if (payloadRecord != null)
{
payloads.Add(payloadRecord);
}
}
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>
/// Posts as json.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="jsonContent">Content of the json.</param>
/// <returns>System.Nullable<RollbarResponse>.</returns>
/// <exception cref="System.Net.Http.HttpRequestException">
/// Preliminary ConnectivityMonitor detected offline status!
/// </exception>
public RollbarResponse?PostAsJson(
string?accessToken,
string?jsonContent
)
{
Assumption.AssertNotNullOrWhiteSpace(accessToken, nameof(accessToken));
Assumption.AssertNotNullOrWhiteSpace(jsonContent, nameof(jsonContent));
if (string.IsNullOrWhiteSpace(accessToken))
{
return(null);
}
// first, let's run quick Internet availability check
// to minimize potential timeout of the following JSON POST call:
if (RollbarConnectivityMonitor.Instance != null &&
!RollbarConnectivityMonitor.Instance.IsConnectivityOn
)
{
throw new HttpRequestException("Preliminary ConnectivityMonitor detected offline status!");
}
using CancellationTokenSource cancellationTokenSource = new();
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>
/// 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);
}
if (payloadBundle.AsHttpContentToSend == null)
{
return(null);
}
Task <string> task = payloadBundle.AsHttpContentToSend.ReadAsStringAsync();
task.Wait();
string payloadContent = task.Result;
Payload?payload = payloadBundle.GetPayload();
if (payload != null && !string.IsNullOrWhiteSpace(payloadContent))
{
return(_storeRepository?.CreatePayloadRecord(payload, payloadContent));
}
else
{
return(null);
}
}
catch (System.Exception ex)
{
RollbarErrorUtility.Report(
payloadQueue.Logger,
payloadBundle.GetPayload(),
InternalRollbarError.PersistentPayloadRecordError,
"While attempting to build persistent payload record...",
ex,
null
);
return(null);
}
}
/// <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>System.Nullable<RollbarResponse>.</returns>
/// <exception cref="System.Net.Http.HttpRequestException">Preliminary ConnectivityMonitor detected offline status!</exception>
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 (RollbarConnectivityMonitor.Instance != null &&
!RollbarConnectivityMonitor.Instance.IsConnectivityOn
)
{
throw new HttpRequestException("Preliminary ConnectivityMonitor detected offline status!");
}
using CancellationTokenSource cancellationTokenSource = new();
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>
/// Tries the posting.
/// </summary>
/// <param name="payloadRecord">The payload record.</param>
/// <returns>RollbarResponse.</returns>
private RollbarResponse?TryPosting(IPayloadRecord payloadRecord)
{
if (payloadRecord.ConfigJson == null)
{
return(null);
}
IRollbarLoggerConfig?config = JsonConvert.DeserializeObject <RollbarLoggerConfig>(payloadRecord.ConfigJson);
if (config == null)
{
return(null);
}
RollbarClient rollbarClient = new RollbarClient(config);
try
{
RollbarResponse?response =
rollbarClient.PostAsJson(config.RollbarDestinationOptions.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>
/// 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) ||
((this._payloadQueue.AccessTokenQueuesMetadata != null) && this._payloadQueue.AccessTokenQueuesMetadata.IsTransmissionSuspended)
)
{
// 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);
}
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).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>
/// Ensures the HTTP content to send.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns><c>true</c> if XXXX, <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 (this._payloadTruncator == null ||
!this._payloadTruncator.TruncatePayload(payloadBundle)
)
{
return(false);
}
if (this._payloadScrubber == null ||
!this._payloadScrubber.ScrubHttpMessages(payloadBundle)
)
{
return(false);
}
string?jsonData = SerializePayloadAsJsonString(payloadBundle);
if (string.IsNullOrWhiteSpace(jsonData))
{
return(false);
}
try
{
jsonData = this._payloadScrubber.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)
);
#pragma warning disable CA1307 // Specify StringComparison for clarity
_ = Assumption.AssertTrue(
string.Equals(payload !.AccessToken, this._rollbarLoggerConfig.RollbarDestinationOptions.AccessToken),
nameof(payload.AccessToken)
);
#pragma warning restore CA1307 // Specify StringComparison for clarity
return(true);
}
/// <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.RollbarDestinationOptions.AccessToken, data);
this._payload.PayloadBundle = this;
try // payload check-ignore:
{
if (this._rollbarLogger?.Config.RollbarPayloadManipulationOptions.CheckIgnore != null &&
this._rollbarLogger.Config.RollbarPayloadManipulationOptions.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,
GetPrimaryErrorCollector()
);
}
this._ignorable = false;
try // payload transformation:
{
this._rollbarLogger?.Config.RollbarPayloadManipulationOptions.Transform?.Invoke(this._payload);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadTransformError,
"While transforming a payload...",
exception,
GetPrimaryErrorCollector()
);
}
try // payload truncation:
{
this._rollbarLogger?.Config.RollbarPayloadManipulationOptions.Truncate?.Invoke(this._payload);
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadTruncationError,
"While truncating a payload...",
exception,
GetPrimaryErrorCollector()
);
}
try
{
this._payload.Validate();
}
catch (System.Exception exception)
{
RollbarErrorUtility.Report(
this._rollbarLogger,
this._payload,
InternalRollbarError.PayloadValidationError,
"While validating a payload...",
exception,
GetPrimaryErrorCollector()
);
}
}
}
return(this._payload);
}
