/// <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.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>
/// 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 (RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions.ReportingQueueDepth == this._queue.Count)
{
this._queue.Dequeue();
}
this._queue.Enqueue(payload);
}
}
/// <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>
/// Scrubs the HTTP messages.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <returns><c>true</c> if scrubbed successfully, <c>false</c> otherwise.</returns>
public bool ScrubHttpMessages(PayloadBundle payloadBundle)
{
Payload?payload = payloadBundle.GetPayload();
if (payload == null)
{
return(true);
}
DTOs.Request?request = payload.Data.Request;
if (request?.PostBody is string requestBody &&
request.Headers != null &&
request.Headers.TryGetValue("Content-Type", out string?requestContentTypeHeader)
)
{
request.PostBody =
this.ScrubHttpMessageBodyContentString(
requestBody,
requestContentTypeHeader,
this.ScrubMask,
this.PayloadFieldNames,
this.HttpRequestBodyPaths);
}
DTOs.Response?response = payload.Data.Response;
if (response?.Body is string responseBody &&
response.Headers != null &&
response.Headers.TryGetValue("Content-Type", out string?responseContentTypeHeader)
)
{
response.Body =
this.ScrubHttpMessageBodyContentString(
responseBody,
responseContentTypeHeader,
this.ScrubMask,
this.PayloadFieldNames,
this.HttpResponseBodyPaths);
}
return(true);
}
/// <summary>
/// Post as json as an asynchronous operation.
/// </summary>
/// <param name="payloadBundle">The payload bundle.</param>
/// <param name="cancellationToken">
/// The cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>A Task<RollbarResponse> representing the asynchronous operation.</returns>
public async Task <RollbarResponse?> PostAsJsonAsync(
PayloadBundle payloadBundle,
CancellationToken?cancellationToken = null
)
{
Assumption.AssertNotNull(payloadBundle, nameof(payloadBundle));
// make sure there anything meaningful to send:
if (string.IsNullOrWhiteSpace(this._rollbarLoggerConfig.RollbarDestinationOptions.AccessToken) ||
!EnsureHttpContentToSend(payloadBundle)
)
{
return(null);
}
return(await PostAsJsonAsync(
this._rollbarLoggerConfig.RollbarDestinationOptions.AccessToken !,
payloadBundle.AsHttpContentToSend !,
cancellationToken
));
}
/// <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>
/// 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);
}
