private static string PrintQueueMessage(PeekedMessage message)
{
return(String.Format("QueueMessage: Id = {0}, DequeueCount = {1}, Content = {2}",
message.MessageId,
message.DequeueCount,
message.MessageText));
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueMessageDecodingFailedEventArgs"/>.
/// </summary>
/// <param name="queueClient">The <see cref="QueueClient"/> that has received invalid message.</param>
/// <param name="receivedMessage">The received <see cref="QueueMessage"/> message.</param>
/// <param name="peekedMessage">The peeked <see cref="PeekedMessage"/> message.</param>
/// <param name="isRunningSynchronously">
/// A value indicating whether the event handler was invoked
/// synchronously or asynchronously. Please see
/// <see cref="Azure.Core.SyncAsyncEventHandler{T}"/> for more details.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token related to the original operation that raised
/// the event. It's important for your handler to pass this token
/// along to any asynchronous or long-running synchronous operations
/// that take a token so cancellation will correctly propagate. The
/// default value is <see cref="CancellationToken.None"/>.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="queueClient"/> is null.
/// </exception>
public QueueMessageDecodingFailedEventArgs(
QueueClient queueClient,
QueueMessage receivedMessage,
PeekedMessage peekedMessage,
bool isRunningSynchronously,
CancellationToken cancellationToken)
: base(isRunningSynchronously, cancellationToken)
{
Argument.AssertNotNull(queueClient, nameof(queueClient));
Queue = queueClient;
ReceivedMessage = receivedMessage;
PeekedMessage = peekedMessage;
}
public async Task <QueueTriggerMetrics> GetMetricsAsync()
{
int queueLength = 0;
TimeSpan queueTime = TimeSpan.Zero;
try
{
QueueProperties queueProperties = await _queue.GetPropertiesAsync().ConfigureAwait(false);
queueLength = queueProperties.ApproximateMessagesCount;
if (queueLength > 0)
{
PeekedMessage message = (await _queue.PeekMessagesAsync(1).ConfigureAwait(false)).Value.FirstOrDefault();
if (message != null)
{
if (message.InsertedOn.HasValue)
{
queueTime = DateTime.UtcNow.Subtract(message.InsertedOn.Value.DateTime);
}
}
else
{
// ApproximateMessageCount often returns a stale value,
// especially when the queue is empty.
queueLength = 0;
}
}
}
catch (RequestFailedException ex)
{
if (ex.IsNotFoundQueueNotFound() ||
ex.IsConflictQueueBeingDeletedOrDisabled() ||
ex.IsServerSideError())
{
// ignore transient errors, and return default metrics
// E.g. if the queue doesn't exist, we'll return a zero queue length
// and scale in
_logger.LogWarning($"Error querying for queue scale status: {ex.Message}");
}
}
return(new QueueTriggerMetrics
{
QueueLength = queueLength,
QueueTime = queueTime,
Timestamp = DateTime.UtcNow
});
}
static void WriteOutMessage(PeekedMessage message)
{
var bytes = Convert.FromBase64String(message.MessageText);
var json = Encoding.UTF8.GetString(bytes);
var byteOrderMarkUtf8 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble());
if (json.StartsWith(json))
{
json = json.Remove(0, byteOrderMarkUtf8.Length);
}
dynamic parsedJson = JsonConvert.DeserializeObject(json);
Debug.WriteLine("Message contents:");
Debug.WriteLine(JsonConvert.SerializeObject((object)parsedJson, Formatting.Indented));
var body = (string)parsedJson.Body;
Debug.WriteLine("Deserialized message body:");
Debug.WriteLine(body.Base64Decode());
}
