public async Task TransactionalSendMultipleSessions()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message1 = GetMessage("session1");
ServiceBusMessage message2 = GetMessage("session2");
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendAsync(message1);
await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow);
ts.Complete();
}
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message1.Body.ToArray(), receivedMessage.Body.ToArray());
await receiver.CompleteAsync(receivedMessage);
receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message2.Body.ToArray(), receivedMessage.Body.ToArray());
await receiver.CompleteAsync(receivedMessage);
};
}
public async Task ScheduleMessageLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportSender = new Mock <TransportSender>();
var mockConnection = GetMockConnection(mockTransportSender);
var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object)
{
Logger = mockLogger.Object
};
var scheduleTime = DateTimeOffset.UtcNow.AddMinutes(1);
await sender.ScheduleMessageAsync(GetMessage(), scheduleTime);
mockLogger
.Verify(
log => log.ScheduleMessageStart(
sender.Identifier,
scheduleTime.ToString()),
Times.Once);
mockLogger
.Verify(
log => log.ScheduleMessageComplete(
sender.Identifier),
Times.Once);
}
public async Task TransactionalSendMultipleSessionsRollback()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
var options = new ServiceBusClientOptions();
options.RetryOptions.TryTimeout = TimeSpan.FromSeconds(5);
options.RetryOptions.MaxRetries = 0;
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message1 = GetMessage("session1");
ServiceBusMessage message2 = GetMessage("session2");
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendAsync(message1);
await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow.AddMinutes(1));
}
Assert.That(
async() =>
await client.CreateSessionReceiverAsync(scope.QueueName), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.ServiceTimeout));
};
}
public async Task ScheduleMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage("Hello world!");
#region Snippet:ServiceBusSchedule
long seq = await sender.ScheduleMessageAsync(
message,
DateTimeOffset.Now.AddDays(1));
#endregion
// create a receiver that we can use to peek the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
Assert.IsNotNull(await receiver.PeekMessageAsync());
// cancel the scheduled messaged, thereby deleting from the service
#region Snippet:ServiceBusCancelScheduled
await sender.CancelScheduledMessageAsync(seq);
#endregion
Assert.IsNull(await receiver.PeekMessageAsync());
}
}
public async ValueTask Reschedule(DateTimeOffset deliveryDate)
{
var message = new ServiceBusMessage(_azureContext.Message);
message.ApplicationProperties[nameof(Redeliveries)] = Redeliveries;
await _sender.ScheduleMessageAsync(message, deliveryDate);
}
public async Task ScheduleMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// get the sender
ServiceBusSender sender = client.GetSender(queueName);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!"));
// schedule the message for tomorrow
// this prevents the message from being enqueued until tomorrow, but it can still be peeked
long seq = await sender.ScheduleMessageAsync(
message,
DateTimeOffset.Now.AddDays(1));
// get a receiver that we can use to peek the message
ServiceBusReceiver receiver = client.GetReceiver(queueName);
Assert.IsNotNull(await receiver.PeekAsync());
// cancel the scheduled messaged, thereby deleting from the service
await sender.CancelScheduledMessageAsync(seq);
Assert.IsNull(await receiver.PeekAsync());
}
}
public static async Task SendServiceBusMessageAsync(ServiceBusSender queueSender, Azure.Messaging.ServiceBus.ServiceBusMessage message, ILogger log, TimeSpan delay)
{
if (queueSender == null)
{
throw new ArgumentNullException(nameof(queueSender));
}
log.LogInformation($"Sending message with delay of {delay.TotalMinutes} minutes.");
await queueSender.ScheduleMessageAsync(message, DateTimeOffset.Now.Add(delay)).ConfigureAwait(false);
}
public static async Task <long> SendScheduledMessageAsync(string connectionString, string queueName, string messageText, DateTimeOffset timeOffset)
{
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a message that we can send. UTF-8 encoding is used when providing a string.
ServiceBusMessage message = new ServiceBusMessage(messageText);
// send the message
return(await sender.ScheduleMessageAsync(message, timeOffset));
}
public async Task <long> SendAsync(string message, int delayInMilliseconds = 0, CancellationToken cancellationToken = default)
{
if (delayInMilliseconds <= 0)
{
await Client.SendMessageAsync(new ServiceBusMessage(message), cancellationToken).NoContext();
return(0);
}
else
{
return(await Client.ScheduleMessageAsync(new ServiceBusMessage(message), DateTime.UtcNow.AddMilliseconds(delayInMilliseconds), cancellationToken).NoContext());
}
}
public void ScheduleMessageExceptionLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportSender = new Mock <TransportSender>();
var mockConnection = GetMockConnection(mockTransportSender);
var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object)
{
Logger = mockLogger.Object
};
mockTransportSender.Setup(
sender => sender.ScheduleMessageAsync(
It.IsAny <ServiceBusMessage>(),
It.IsAny <CancellationToken>()))
.Throws(new Exception());
var scheduleTime = DateTimeOffset.UtcNow.AddMinutes(1);
Assert.That(
async() => await sender.ScheduleMessageAsync(GetMessage(), scheduleTime),
Throws.InstanceOf <Exception>());
mockLogger
.Verify(
log => log.ScheduleMessageStart(
sender.Identifier,
scheduleTime.ToString()),
Times.Once);
mockLogger
.Verify(
log => log.ScheduleMessageException(
sender.Identifier,
It.IsAny <string>()),
Times.Once);
}
public async Task TransactionalCancelScheduleRollback()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message = GetMessage();
long seq = await sender.ScheduleMessageAsync(message, DateTimeOffset.UtcNow.AddMinutes(1));
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.CancelScheduledMessageAsync(seq);
}
ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);
ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync();
Assert.NotNull(msg);
};
}
public async Task TransactionalSendMultipleSessionsRollback()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = CreateClient();
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusMessage message1 = GetMessage("session1");
ServiceBusMessage message2 = GetMessage("session2");
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendMessageAsync(message1);
await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow.AddMinutes(1));
}
Assert.That(
async() =>
await CreateNoRetryClient().AcceptNextSessionAsync(scope.QueueName), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusFailureReason.ServiceTimeout));
};
}
public async Task ScheduleMessageLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportSender = new Mock <TransportSender>();
var mockConnection = GetMockConnection(mockTransportSender);
var sender = new ServiceBusSender(
"queueName",
new ServiceBusSenderOptions(),
mockConnection.Object,
new ServiceBusPlugin[] { })
{
Logger = mockLogger.Object
};
mockTransportSender.Setup(
sender => sender.ScheduleMessagesAsync(
It.IsAny <IReadOnlyList <ServiceBusMessage> >(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult((IReadOnlyList <long>) new List <long> {
1
}));
var scheduleTime = DateTimeOffset.UtcNow.AddMinutes(1);
await sender.ScheduleMessageAsync(GetMessage(), scheduleTime);
mockLogger
.Verify(
log => log.ScheduleMessagesStart(
sender.Identifier,
1,
It.IsAny <string>()),
Times.Once);
mockLogger
.Verify(
log => log.ScheduleMessagesComplete(
sender.Identifier),
Times.Once);
}
public async Task LogsEvents()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = CreateNoRetryClient();
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.FullyQualifiedNamespace));
var messageCount = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
_listener.EventsById(ServiceBusEventSource.ClientCreateStartEvent).Where(e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.FullyQualifiedNamespace) && e.Payload.Contains(sender.EntityPath));
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
_listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier));
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
_listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationCompleteEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateSendLinkCompleteEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.SendMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.SendMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
Assert.That(
async() => await client.AcceptNextSessionAsync(scope.QueueName),
Throws.InstanceOf <InvalidOperationException>());
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace) && e.Payload.Contains(scope.QueueName));
_listener.SingleEventById(ServiceBusEventSource.ClientCreateExceptionEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace) && e.Payload.Contains(scope.QueueName));
var receiver = client.CreateReceiver(scope.QueueName);
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace));
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(item.DeliveryCount, 1);
}
}
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
Assert.IsTrue(_listener.EventsById(ServiceBusEventSource.ReceiveMessageStartEvent).Any());
Assert.IsTrue(_listener.EventsById(ServiceBusEventSource.ReceiveMessageCompleteEvent).Any());
Assert.AreEqual(0, remainingMessages);
messageEnum.Reset();
foreach (var item in await receiver.PeekMessagesAsync(messageCount))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
}
_listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.PeekMessageStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.PeekMessageCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
var seq = await sender.ScheduleMessageAsync(new ServiceBusMessage(), DateTimeOffset.UtcNow.AddMinutes(1));
_listener.SingleEventById(ServiceBusEventSource.ScheduleMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ScheduleMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
await sender.CancelScheduledMessageAsync(seq);
_listener.SingleEventById(ServiceBusEventSource.CancelScheduledMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CancelScheduledMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
await receiver.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier));
// link closed event is fired asynchronously, so add a small delay
await Task.Delay(TimeSpan.FromSeconds(5));
_listener.SingleEventById(ServiceBusEventSource.ReceiveLinkClosedEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ManagementLinkClosedEvent, e => e.Payload.Contains(receiver.Identifier));
Assert.IsFalse(_listener.EventsById(ServiceBusEventSource.MaxMessagesExceedsPrefetchEvent).Any());
receiver = client.CreateReceiver(scope.QueueName, new ServiceBusReceiverOptions {
PrefetchCount = 10
});
await receiver.ReceiveMessagesAsync(20, TimeSpan.FromSeconds(1));
_listener.SingleEventById(ServiceBusEventSource.MaxMessagesExceedsPrefetchEvent, e => e.Payload.Contains(receiver.Identifier));
await sender.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier));
await client.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier));
}
}
public void ScheduleMessage(ServiceBusMessage message, DateTimeOffset scheduleEnqueueTime)
{
_serviceBusSender.ScheduleMessageAsync(message, scheduleEnqueueTime).Wait();
}
public async Task SenderReceiverActivities(bool useSessions)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: useSessions))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
string sessionId = null;
if (useSessions)
{
sessionId = "sessionId";
}
int numMessages = 5;
var msgs = ServiceBusTestUtilities.GetMessages(numMessages, sessionId);
await sender.SendMessagesAsync(msgs);
Activity[] sendActivities = AssertSendActivities(useSessions, sender, msgs);
ServiceBusReceiver receiver = null;
if (useSessions)
{
receiver = await client.AcceptNextSessionAsync(scope.QueueName);
}
else
{
receiver = client.CreateReceiver(scope.QueueName);
}
var remaining = numMessages;
List <ServiceBusReceivedMessage> receivedMsgs = new List <ServiceBusReceivedMessage>();
while (remaining > 0)
{
// loop in case we don't receive all messages in one attempt
var received = await receiver.ReceiveMessagesAsync(remaining);
receivedMsgs.AddRange(received);
var receiveScope = _listener.AssertAndRemoveScope(DiagnosticProperty.ReceiveActivityName);
AssertCommonTags(receiveScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
var receiveLinkedActivities = receiveScope.LinkedActivities;
for (int i = 0; i < receiveLinkedActivities.Count; i++)
{
Assert.AreEqual(sendActivities[i].ParentId, receiveLinkedActivities[i].ParentId);
}
remaining -= received.Count;
}
var msgIndex = 0;
var completed = receivedMsgs[msgIndex];
await receiver.CompleteMessageAsync(completed);
var completeScope = _listener.AssertAndRemoveScope(DiagnosticProperty.CompleteActivityName);
AssertCommonTags(completeScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
var deferred = receivedMsgs[++msgIndex];
await receiver.DeferMessageAsync(deferred);
var deferredScope = _listener.AssertAndRemoveScope(DiagnosticProperty.DeferActivityName);
AssertCommonTags(deferredScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
var deadLettered = receivedMsgs[++msgIndex];
await receiver.DeadLetterMessageAsync(deadLettered);
var deadLetterScope = _listener.AssertAndRemoveScope(DiagnosticProperty.DeadLetterActivityName);
AssertCommonTags(deadLetterScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
var abandoned = receivedMsgs[++msgIndex];
await receiver.AbandonMessageAsync(abandoned);
var abandonScope = _listener.AssertAndRemoveScope(DiagnosticProperty.AbandonActivityName);
AssertCommonTags(abandonScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
var receiveDeferMsg = await receiver.ReceiveDeferredMessageAsync(deferred.SequenceNumber);
var receiveDeferScope = _listener.AssertAndRemoveScope(DiagnosticProperty.ReceiveDeferredActivityName);
AssertCommonTags(receiveDeferScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
// renew lock
if (useSessions)
{
var sessionReceiver = (ServiceBusSessionReceiver)receiver;
await sessionReceiver.RenewSessionLockAsync();
var renewSessionScope = _listener.AssertAndRemoveScope(DiagnosticProperty.RenewSessionLockActivityName);
AssertCommonTags(renewSessionScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
// set state
var state = new BinaryData("state");
await sessionReceiver.SetSessionStateAsync(state);
var setStateScope = _listener.AssertAndRemoveScope(DiagnosticProperty.SetSessionStateActivityName);
AssertCommonTags(setStateScope.Activity, sessionReceiver.EntityPath, sessionReceiver.FullyQualifiedNamespace);
// get state
var getState = await sessionReceiver.GetSessionStateAsync();
Assert.AreEqual(state.ToArray(), getState.ToArray());
var getStateScope = _listener.AssertAndRemoveScope(DiagnosticProperty.GetSessionStateActivityName);
AssertCommonTags(getStateScope.Activity, sessionReceiver.EntityPath, sessionReceiver.FullyQualifiedNamespace);
}
else
{
await receiver.RenewMessageLockAsync(receivedMsgs[4]);
var renewMessageScope = _listener.AssertAndRemoveScope(DiagnosticProperty.RenewMessageLockActivityName);
AssertCommonTags(renewMessageScope.Activity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
}
// schedule
msgs = ServiceBusTestUtilities.GetMessages(numMessages, sessionId);
foreach (var msg in msgs)
{
var seq = await sender.ScheduleMessageAsync(msg, DateTimeOffset.UtcNow.AddMinutes(1));
Assert.IsNotNull(msg.ApplicationProperties[DiagnosticProperty.DiagnosticIdAttribute]);
var messageScope = _listener.AssertAndRemoveScope(DiagnosticProperty.MessageActivityName);
AssertCommonTags(messageScope.Activity, sender.EntityPath, sender.FullyQualifiedNamespace);
var scheduleScope = _listener.AssertAndRemoveScope(DiagnosticProperty.ScheduleActivityName);
AssertCommonTags(scheduleScope.Activity, sender.EntityPath, sender.FullyQualifiedNamespace);
var linkedActivities = scheduleScope.LinkedActivities;
Assert.AreEqual(1, linkedActivities.Count);
Assert.AreEqual(messageScope.Activity.Id, linkedActivities[0].ParentId);
await sender.CancelScheduledMessageAsync(seq);
var cancelScope = _listener.AssertAndRemoveScope(DiagnosticProperty.CancelActivityName);
AssertCommonTags(cancelScope.Activity, sender.EntityPath, sender.FullyQualifiedNamespace);
}
// send a batch
var batch = await sender.CreateMessageBatchAsync();
for (int i = 0; i < numMessages; i++)
{
batch.TryAddMessage(ServiceBusTestUtilities.GetMessage(sessionId));
}
await sender.SendMessagesAsync(batch);
AssertSendActivities(useSessions, sender, batch.AsReadOnly <ServiceBusMessage>());
};
}
public async Task SenderReceiverActivities(bool useSessions)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: useSessions))
{
using var listener = new TestDiagnosticListener(EntityScopeFactory.DiagnosticNamespace);
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
string sessionId = null;
if (useSessions)
{
sessionId = "sessionId";
}
int numMessages = 5;
var msgs = GetMessages(numMessages, sessionId);
await sender.SendMessagesAsync(msgs);
Activity[] sendActivities = AssertSendActivities(useSessions, sender, msgs, listener);
ServiceBusReceiver receiver = null;
if (useSessions)
{
receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
}
else
{
receiver = client.CreateReceiver(scope.QueueName);
}
var remaining = numMessages;
List <ServiceBusReceivedMessage> receivedMsgs = new List <ServiceBusReceivedMessage>();
while (remaining > 0)
{
// loop in case we don't receive all messages in one attempt
var received = await receiver.ReceiveMessagesAsync(remaining);
receivedMsgs.AddRange(received);
(string Key, object Value, DiagnosticListener)receiveStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveActivityName + ".Start", receiveStart.Key);
Activity receiveActivity = (Activity)receiveStart.Value;
AssertCommonTags(receiveActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
receiveActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.RequestedMessageCountAttribute,
remaining.ToString()));
CollectionAssert.Contains(
receiveActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.MessageIdAttribute,
string.Join(",", received.Select(m => m.MessageId).ToArray())));
remaining -= received.Count;
if (useSessions)
{
CollectionAssert.Contains(
receiveActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
string.Join(",", msgs.Select(m => m.SessionId).Distinct().ToArray())));
}
var receiveLinkedActivities = ((IEnumerable <Activity>)receiveActivity.GetType().GetProperty("Links").GetValue(receiveActivity)).ToArray();
for (int i = 0; i < receiveLinkedActivities.Length; i++)
{
Assert.AreEqual(sendActivities[i].ParentId, receiveLinkedActivities[i].ParentId);
}
(string Key, object Value, DiagnosticListener)receiveStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveActivityName + ".Stop", receiveStop.Key);
}
var msgIndex = 0;
var completed = receivedMsgs[msgIndex];
await receiver.CompleteMessageAsync(completed);
(string Key, object Value, DiagnosticListener)completeStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.CompleteActivityName + ".Start", completeStart.Key);
Activity completeActivity = (Activity)completeStart.Value;
AssertCommonTags(completeActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(completeActivity, completed.LockToken);
(string Key, object Value, DiagnosticListener)completeStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.CompleteActivityName + ".Stop", completeStop.Key);
var deferred = receivedMsgs[++msgIndex];
await receiver.DeferMessageAsync(deferred);
(string Key, object Value, DiagnosticListener)deferStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeferActivityName + ".Start", deferStart.Key);
Activity deferActivity = (Activity)deferStart.Value;
AssertCommonTags(deferActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(deferActivity, deferred.LockToken);
(string Key, object Value, DiagnosticListener)deferStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeferActivityName + ".Stop", deferStop.Key);
var deadLettered = receivedMsgs[++msgIndex];
await receiver.DeadLetterMessageAsync(deadLettered);
(string Key, object Value, DiagnosticListener)deadLetterStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeadLetterActivityName + ".Start", deadLetterStart.Key);
Activity deadLetterActivity = (Activity)deadLetterStart.Value;
AssertCommonTags(deadLetterActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(deadLetterActivity, deadLettered.LockToken);
(string Key, object Value, DiagnosticListener)deadletterStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.DeadLetterActivityName + ".Stop", deadletterStop.Key);
var abandoned = receivedMsgs[++msgIndex];
await receiver.AbandonMessageAsync(abandoned);
(string Key, object Value, DiagnosticListener)abandonStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.AbandonActivityName + ".Start", abandonStart.Key);
Activity abandonActivity = (Activity)abandonStart.Value;
AssertCommonTags(abandonActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(abandonActivity, abandoned.LockToken);
(string Key, object Value, DiagnosticListener)abandonStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.AbandonActivityName + ".Stop", abandonStop.Key);
var receiveDeferMsg = await receiver.ReceiveDeferredMessageAsync(deferred.SequenceNumber);
(string Key, object Value, DiagnosticListener)receiveDeferStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveDeferredActivityName + ".Start", receiveDeferStart.Key);
Activity receiveDeferActivity = (Activity)receiveDeferStart.Value;
AssertCommonTags(receiveDeferActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
receiveDeferActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.MessageIdAttribute,
deferred.MessageId));
CollectionAssert.Contains(
receiveDeferActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SequenceNumbersAttribute,
deferred.SequenceNumber.ToString()));
(string Key, object Value, DiagnosticListener)receiveDeferStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ReceiveDeferredActivityName + ".Stop", receiveDeferStop.Key);
// renew lock
if (useSessions)
{
var sessionReceiver = (ServiceBusSessionReceiver)receiver;
await sessionReceiver.RenewSessionLockAsync();
(string Key, object Value, DiagnosticListener)renewStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewSessionLockActivityName + ".Start", renewStart.Key);
Activity renewActivity = (Activity)renewStart.Value;
AssertCommonTags(renewActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
renewActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
"sessionId"));
(string Key, object Value, DiagnosticListener)renewStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewSessionLockActivityName + ".Stop", renewStop.Key);
// set state
var state = Encoding.UTF8.GetBytes("state");
await sessionReceiver.SetSessionStateAsync(state);
(string Key, object Value, DiagnosticListener)setStateStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.SetSessionStateActivityName + ".Start", setStateStart.Key);
Activity setStateActivity = (Activity)setStateStart.Value;
AssertCommonTags(setStateActivity, sessionReceiver.EntityPath, sessionReceiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
setStateActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
"sessionId"));
(string Key, object Value, DiagnosticListener)setStateStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.SetSessionStateActivityName + ".Stop", setStateStop.Key);
// get state
var getState = await sessionReceiver.GetSessionStateAsync();
Assert.AreEqual(state, getState);
(string Key, object Value, DiagnosticListener)getStateStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.GetSessionStateActivityName + ".Start", getStateStart.Key);
Activity getStateActivity = (Activity)getStateStart.Value;
AssertCommonTags(getStateActivity, sessionReceiver.EntityPath, sessionReceiver.FullyQualifiedNamespace);
CollectionAssert.Contains(
getStateActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.SessionIdAttribute,
"sessionId"));
(string Key, object Value, DiagnosticListener)getStateStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.GetSessionStateActivityName + ".Stop", getStateStop.Key);
}
else
{
await receiver.RenewMessageLockAsync(receivedMsgs[4]);
(string Key, object Value, DiagnosticListener)renewStart = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewMessageLockActivityName + ".Start", renewStart.Key);
Activity renewActivity = (Activity)renewStart.Value;
AssertCommonTags(renewActivity, receiver.EntityPath, receiver.FullyQualifiedNamespace);
AssertLockTokensTag(renewActivity, receivedMsgs[4].LockToken);
CollectionAssert.Contains(
renewActivity.Tags,
new KeyValuePair <string, string>(
DiagnosticProperty.LockedUntilAttribute,
receivedMsgs[4].LockedUntil.ToString()));
(string Key, object Value, DiagnosticListener)renewStop = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.RenewMessageLockActivityName + ".Stop", renewStop.Key);
}
// schedule
msgs = GetMessages(numMessages, sessionId);
foreach (var msg in msgs)
{
var seq = await sender.ScheduleMessageAsync(msg, DateTimeOffset.UtcNow.AddMinutes(1));
Assert.IsNotNull(msg.Properties[DiagnosticProperty.DiagnosticIdAttribute]);
(string Key, object Value, DiagnosticListener)startMessage = listener.Events.Dequeue();
Activity messageActivity = (Activity)startMessage.Value;
AssertCommonTags(messageActivity, sender.EntityPath, sender.FullyQualifiedNamespace);
Assert.AreEqual(DiagnosticProperty.MessageActivityName + ".Start", startMessage.Key);
(string Key, object Value, DiagnosticListener)stopMessage = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.MessageActivityName + ".Stop", stopMessage.Key);
(string Key, object Value, DiagnosticListener)startSchedule = listener.Events.Dequeue();
AssertCommonTags((Activity)startSchedule.Value, sender.EntityPath, sender.FullyQualifiedNamespace);
Assert.AreEqual(DiagnosticProperty.ScheduleActivityName + ".Start", startSchedule.Key);
(string Key, object Value, DiagnosticListener)stopSchedule = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.ScheduleActivityName + ".Stop", stopSchedule.Key);
var linkedActivities = ((IEnumerable <Activity>)startSchedule.Value.GetType().GetProperty("Links").GetValue(startSchedule.Value)).ToArray();
Assert.AreEqual(1, linkedActivities.Length);
Assert.AreEqual(messageActivity.Id, linkedActivities[0].ParentId);
await sender.CancelScheduledMessageAsync(seq);
(string Key, object Value, DiagnosticListener)startCancel = listener.Events.Dequeue();
AssertCommonTags((Activity)startCancel.Value, sender.EntityPath, sender.FullyQualifiedNamespace);
Assert.AreEqual(DiagnosticProperty.CancelActivityName + ".Start", startCancel.Key);
(string Key, object Value, DiagnosticListener)stopCancel = listener.Events.Dequeue();
Assert.AreEqual(DiagnosticProperty.CancelActivityName + ".Stop", stopCancel.Key);
}
// send a batch
var batch = await sender.CreateMessageBatchAsync();
for (int i = 0; i < numMessages; i++)
{
batch.TryAddMessage(GetMessage(sessionId));
}
await sender.SendMessagesAsync(batch);
AssertSendActivities(useSessions, sender, batch.AsEnumerable <ServiceBusMessage>(), listener);
};
}
