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()); }