diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpClient.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpClient.cs index 22a4a8fda87f..74a15ebdbdd3 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpClient.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpClient.cs @@ -118,12 +118,14 @@ internal AmqpClient( /// The entity path to send the message to. /// The entity path to route the message through. Useful when using transactions. /// The policy which governs retry behavior and try timeouts. + /// The identifier for the sender. /// /// A configured in the requested manner. public override TransportSender CreateSender( string entityPath, string viaEntityPath, - ServiceBusRetryPolicy retryPolicy) + ServiceBusRetryPolicy retryPolicy, + string identifier) { Argument.AssertNotClosed(_closed, nameof(AmqpClient)); @@ -132,7 +134,8 @@ public override TransportSender CreateSender( entityPath, viaEntityPath, ConnectionScope, - retryPolicy + retryPolicy, + identifier ); } @@ -182,11 +185,13 @@ public override TransportReceiver CreateReceiver( /// /// The path of the Service Bus subscription to which the rule manager is bound. /// The policy which governs retry behavior and try timeouts. + /// The identifier for the rule manager. /// /// A configured in the requested manner. public override TransportRuleManager CreateRuleManager( string subscriptionPath, - ServiceBusRetryPolicy retryPolicy) + ServiceBusRetryPolicy retryPolicy, + string identifier) { Argument.AssertNotClosed(_closed, nameof(AmqpClient)); @@ -194,7 +199,8 @@ public override TransportRuleManager CreateRuleManager( ( subscriptionPath, ConnectionScope, - retryPolicy + retryPolicy, + identifier ); } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpConnectionScope.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpConnectionScope.cs index 77152894ff93..c3db25b9460d 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpConnectionScope.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpConnectionScope.cs @@ -196,7 +196,7 @@ private async Task CreateControllerAsync(TimeSpan timeout) await amqpSession.CloseAsync(timeout).ConfigureAwait(false); } - MessagingEventSource.Log.AmqpCreateControllerException(ActiveConnection.ToString(), exception); + ServiceBusEventSource.Log.CreateControllerException(ActiveConnection.ToString(), exception.ToString()); throw; } @@ -217,8 +217,8 @@ protected AmqpConnectionScope() /// /// Opens an AMQP link for use with management operations. /// - /// - /// + /// The path for the entity. + /// The identifier for the sender or receiver that is opening a management link. /// The timeout to apply when creating the link. /// An optional instance to signal the request to cancel the operation. /// @@ -231,25 +231,35 @@ protected AmqpConnectionScope() /// public virtual async Task OpenManagementLinkAsync( string entityPath, + string identifier, TimeSpan timeout, CancellationToken cancellationToken) { - cancellationToken.ThrowIfCancellationRequested(); - - var stopWatch = ValueStopwatch.StartNew(); - var connection = await ActiveConnection.GetOrCreateAsync(timeout).ConfigureAwait(false); - cancellationToken.ThrowIfCancellationRequested(); + ServiceBusEventSource.Log.CreateManagementLinkStart(identifier); + try + { + cancellationToken.ThrowIfCancellationRequested(); - var link = await CreateManagementLinkAsync( - entityPath, - connection, - timeout.CalculateRemaining(stopWatch.GetElapsedTime()), cancellationToken).ConfigureAwait(false); - cancellationToken.ThrowIfCancellationRequested(); + var stopWatch = ValueStopwatch.StartNew(); + var connection = await ActiveConnection.GetOrCreateAsync(timeout).ConfigureAwait(false); + cancellationToken.ThrowIfCancellationRequested(); - await OpenAmqpObjectAsync(link, timeout.CalculateRemaining(stopWatch.GetElapsedTime())).ConfigureAwait(false); - cancellationToken.ThrowIfCancellationRequested(); + var link = await CreateManagementLinkAsync( + entityPath, + connection, + timeout.CalculateRemaining(stopWatch.GetElapsedTime()), cancellationToken).ConfigureAwait(false); + cancellationToken.ThrowIfCancellationRequested(); - return link; + await OpenAmqpObjectAsync(link, timeout.CalculateRemaining(stopWatch.GetElapsedTime())).ConfigureAwait(false); + cancellationToken.ThrowIfCancellationRequested(); + ServiceBusEventSource.Log.CreateManagementLinkComplete(identifier); + return link; + } + catch (Exception ex) + { + ServiceBusEventSource.Log.CreateManagementLinkException(identifier, ex.ToString()); + throw; + } } /// @@ -261,6 +271,7 @@ public virtual async Task OpenManagementLinkAsync( /// The used to specify how messages are received. Defaults to PeekLock mode. /// /// + /// The identifier for the receive link. /// The timeout to apply when creating the link. /// An optional instance to signal the request to cancel the operation. /// @@ -273,35 +284,44 @@ public virtual async Task OpenReceiverLinkAsync( ReceiveMode receiveMode, string sessionId, bool isSessionReceiver, + string identifier, CancellationToken cancellationToken) { + ServiceBusEventSource.Log.CreateReceiveLinkStart(identifier); + try + { + cancellationToken.ThrowIfCancellationRequested(); - cancellationToken.ThrowIfCancellationRequested(); - - var stopWatch = ValueStopwatch.StartNew(); - var receiverEndpoint = new Uri(ServiceEndpoint, entityPath); - - var connection = await ActiveConnection.GetOrCreateAsync(timeout).ConfigureAwait(false); - cancellationToken.ThrowIfCancellationRequested(); + var stopWatch = ValueStopwatch.StartNew(); + var receiverEndpoint = new Uri(ServiceEndpoint, entityPath); - ReceivingAmqpLink link = await CreateReceivingLinkAsync( - entityPath, - connection, - receiverEndpoint, - timeout.CalculateRemaining(stopWatch.GetElapsedTime()), - prefetchCount, - receiveMode, - sessionId, - isSessionReceiver, - cancellationToken - ).ConfigureAwait(false); + var connection = await ActiveConnection.GetOrCreateAsync(timeout).ConfigureAwait(false); + cancellationToken.ThrowIfCancellationRequested(); - cancellationToken.ThrowIfCancellationRequested(); + ReceivingAmqpLink link = await CreateReceivingLinkAsync( + entityPath, + connection, + receiverEndpoint, + timeout.CalculateRemaining(stopWatch.GetElapsedTime()), + prefetchCount, + receiveMode, + sessionId, + isSessionReceiver, + cancellationToken + ).ConfigureAwait(false); - await OpenAmqpObjectAsync(link, timeout.CalculateRemaining(stopWatch.GetElapsedTime())).ConfigureAwait(false); - cancellationToken.ThrowIfCancellationRequested(); + cancellationToken.ThrowIfCancellationRequested(); - return link; + await OpenAmqpObjectAsync(link, timeout.CalculateRemaining(stopWatch.GetElapsedTime())).ConfigureAwait(false); + cancellationToken.ThrowIfCancellationRequested(); + ServiceBusEventSource.Log.CreateReceiveLinkComplete(identifier); + return link; + } + catch (Exception ex) + { + ServiceBusEventSource.Log.CreateReceiveLinkException(identifier, ex.ToString()); + throw; + } } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs index dd13544b959d..44966e999cdb 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs @@ -142,12 +142,14 @@ public AmqpReceiver( receiveMode: receiveMode, sessionId: sessionId, isSessionReceiver: isSessionReceiver, + identifier: _identifier, cancellationToken: CancellationToken.None), link => CloseLink(link)); _managementLink = new FaultTolerantAmqpObject( timeout => _connectionScope.OpenManagementLinkAsync( _entityPath, + _identifier, timeout, CancellationToken.None), link => CloseLink(link)); @@ -173,7 +175,7 @@ private void CloseLink(RequestResponseAmqpLink link) /// An optional specifying the maximum time to wait for the first message before returning an empty list if no messages have been received. /// An optional instance to signal the request to cancel the operation. /// - /// List of messages received. Returns null if no message is found. + /// List of messages received. Returns an empty list if no message is found. public override async Task> ReceiveBatchAsync( int maxMessages, TimeSpan? maxWaitTime, @@ -195,7 +197,7 @@ await _retryPolicy.RunOperation(async (timeout) => } /// - /// Receives a batch of from the Service Bus entity partition. + /// Receives a batch of from the Service Bus entity. /// /// /// The maximum number of messages to receive in this batch. @@ -204,7 +206,7 @@ await _retryPolicy.RunOperation(async (timeout) => /// The per-try timeout specified in the RetryOptions. /// An optional instance to signal the request to cancel the operation. /// - /// The batch of from the Service Bus entity partition this consumer is associated with. If no events are present, an empty enumerable is returned. + /// The batch of from the Service Bus entity this receiver is associated with. If no messages are present, an empty list is returned. /// private async Task> ReceiveBatchAsyncInternal( int maxMessages, @@ -389,9 +391,9 @@ private async Task DisposeMessagesAsync( ServiceBusEventSource.Log.LinkStateLost( _identifier, receiveLink.Name, - receiveLink.State, + receiveLink.State.ToString(), _isSessionReceiver, - exception); + exception.ToString()); ThrowLockLostException(); } @@ -1229,7 +1231,7 @@ private void OnSessionReceiverLinkClosed(object receiver, EventArgs e) ServiceBusEventSource.Log.SessionReceiverLinkClosed( _identifier, SessionId, - LinkException); + LinkException.ToString()); } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpRuleManager.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpRuleManager.cs index b1fa0f246938..a04345104dc3 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpRuleManager.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpRuleManager.cs @@ -27,6 +27,11 @@ internal class AmqpRuleManager : TransportRuleManager /// private readonly ServiceBusRetryPolicy _retryPolicy; + /// + /// The identifier for the rule manager. + /// + private readonly string _identifier; + /// /// The AMQP connection scope responsible for managing transport constructs for this instance. /// @@ -67,6 +72,7 @@ static AmqpRuleManager() /// The path of the Service Bus subscription to which the rule manager is bound. /// The AMQP connection context for operations. /// The retry policy to consider when an operation fails. + /// The identifier for the rule manager. /// /// /// As an internal type, this class performs only basic sanity checks against its arguments. It @@ -79,7 +85,8 @@ static AmqpRuleManager() public AmqpRuleManager( string subscriptionPath, AmqpConnectionScope connectionScope, - ServiceBusRetryPolicy retryPolicy) + ServiceBusRetryPolicy retryPolicy, + string identifier) { Argument.AssertNotNullOrEmpty(subscriptionPath, nameof(subscriptionPath)); Argument.AssertNotNull(connectionScope, nameof(connectionScope)); @@ -88,10 +95,12 @@ public AmqpRuleManager( _subscriptionPath = subscriptionPath; _connectionScope = connectionScope; _retryPolicy = retryPolicy; + _identifier = identifier; _managementLink = new FaultTolerantAmqpObject( timeout => _connectionScope.OpenManagementLinkAsync( _subscriptionPath, + _identifier, timeout, CancellationToken.None), link => diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs index 3d6cd5d513f5..b4ecc38d4348 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs @@ -10,6 +10,7 @@ using Azure.Core; using Azure.Core.Diagnostics; using Azure.Messaging.ServiceBus.Core; +using Azure.Messaging.ServiceBus.Diagnostics; using Microsoft.Azure.Amqp; using Microsoft.Azure.Amqp.Encoding; using Microsoft.Azure.Amqp.Framing; @@ -48,6 +49,11 @@ internal class AmqpSender : TransportSender /// private readonly string _entityPath; + /// + /// The identifier for the sender. + /// + private readonly string _identifier; + /// /// An optional entity path to route the message through. Useful for transactions. /// @@ -86,6 +92,7 @@ internal class AmqpSender : TransportSender /// The entity path to route the message through. Useful when using transactions. /// The AMQP connection context for operations. /// The retry policy to consider when an operation fails. + /// The identifier for the sender. /// /// /// As an internal type, this class performs only basic sanity checks against its arguments. It @@ -100,13 +107,15 @@ public AmqpSender( string entityPath, string viaEntityPath, AmqpConnectionScope connectionScope, - ServiceBusRetryPolicy retryPolicy) + ServiceBusRetryPolicy retryPolicy, + string identifier) { Argument.AssertNotNullOrEmpty(entityPath, nameof(entityPath)); Argument.AssertNotNull(connectionScope, nameof(connectionScope)); Argument.AssertNotNull(retryPolicy, nameof(retryPolicy)); _entityPath = entityPath; + _identifier = identifier; _viaEntityPath = viaEntityPath; _retryPolicy = retryPolicy; _connectionScope = connectionScope; @@ -122,6 +131,7 @@ public AmqpSender( _managementLink = new FaultTolerantAmqpObject( timeout => _connectionScope.OpenManagementLinkAsync( _entityPath, + identifier, timeout, CancellationToken.None), link => @@ -560,27 +570,36 @@ protected virtual async Task CreateLinkAndEnsureSenderStateAsyn TimeSpan timeout, CancellationToken cancellationToken) { - SendingAmqpLink link = await _connectionScope.OpenSenderLinkAsync( - _entityPath, - _viaEntityPath, - timeout, - cancellationToken).ConfigureAwait(false); + ServiceBusEventSource.Log.CreateSendLinkStart(_identifier); + try + { + SendingAmqpLink link = await _connectionScope.OpenSenderLinkAsync( + _entityPath, + _viaEntityPath, + timeout, + cancellationToken).ConfigureAwait(false); - if (!MaxMessageSize.HasValue) + if (!MaxMessageSize.HasValue) + { + // This delay is necessary to prevent the link from causing issues for subsequent + // operations after creating a batch. Without it, operations using the link consistently + // timeout. The length of the delay does not appear significant, just the act of introducing + // an asynchronous delay. + // + // For consistency the value used by the legacy Service Bus client has been brought forward and + // used here. + + await Task.Delay(15, cancellationToken).ConfigureAwait(false); + MaxMessageSize = (long)link.Settings.MaxMessageSize; + } + ServiceBusEventSource.Log.CreateSendLinkComplete(_identifier); + return link; + } + catch (Exception ex) { - // This delay is necessary to prevent the link from causing issues for subsequent - // operations after creating a batch. Without it, operations using the link consistently - // timeout. The length of the delay does not appear significant, just the act of introducing - // an asynchronous delay. - // - // For consistency the value used by the legacy Service Bus client has been brought forward and - // used here. - - await Task.Delay(15, cancellationToken).ConfigureAwait(false); - MaxMessageSize = (long)link.Settings.MaxMessageSize; + ServiceBusEventSource.Log.CreateSendLinkException(_identifier, ex.ToString()); + throw; } - - return link; } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpTransactionEnlistment.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpTransactionEnlistment.cs index 5446f3578d1b..0ff52f549d43 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpTransactionEnlistment.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpTransactionEnlistment.cs @@ -7,6 +7,7 @@ using Microsoft.Azure.Amqp; using Azure.Messaging.ServiceBus.Primitives; using Microsoft.Azure.Amqp.Transaction; +using Azure.Messaging.ServiceBus.Diagnostics; namespace Azure.Messaging.ServiceBus.Amqp { @@ -38,12 +39,12 @@ protected override async Task OnCreateAsync(TimeSpan FaultTolerantAmqpObject faultTolerantController = _connectionScope.TransactionController; Controller controller = await faultTolerantController.GetOrCreateAsync(timeout).ConfigureAwait(false); AmqpTransactionId = await controller.DeclareAsync().ConfigureAwait(false); - MessagingEventSource.Log.AmqpTransactionDeclared(_transactionId, AmqpTransactionId); + ServiceBusEventSource.Log.TransactionDeclared(_transactionId, AmqpTransactionId); return this; } catch (Exception exception) { - MessagingEventSource.Log.AmqpTransactionInitializeException(_transactionId, exception); + ServiceBusEventSource.Log.TransactionInitializeException(_transactionId, exception.ToString()); _transactionManager.RemoveEnlistment(_transactionId); throw; } @@ -73,7 +74,7 @@ private async Task SinglePhaseCommitAsync(SinglePhaseEnlistment singlePhaseEnlis await controller.DischargeAsync(AmqpTransactionId, fail: false).ConfigureAwait(false); singlePhaseEnlistment.Committed(); - MessagingEventSource.Log.AmqpTransactionDischarged( + ServiceBusEventSource.Log.TransactionDischarged( _transactionId, AmqpTransactionId, false); @@ -82,7 +83,7 @@ private async Task SinglePhaseCommitAsync(SinglePhaseEnlistment singlePhaseEnlis catch (Exception e) { Exception exception = AmqpExceptionHelper.TranslateException(e, null); - MessagingEventSource.Log.AmqpTransactionDischargeException( + ServiceBusEventSource.Log.TransactionDischargeException( _transactionId, AmqpTransactionId, exception); @@ -106,12 +107,12 @@ private async Task RollbackAsync(SinglePhaseEnlistment singlePhaseEnlistment) await controller.DischargeAsync(AmqpTransactionId, fail: true).ConfigureAwait(false); singlePhaseEnlistment.Aborted(); - MessagingEventSource.Log.AmqpTransactionDischarged(_transactionId, AmqpTransactionId, true); + ServiceBusEventSource.Log.TransactionDischarged(_transactionId, AmqpTransactionId, true); } catch (Exception e) { Exception exception = AmqpExceptionHelper.TranslateException(e, null); - MessagingEventSource.Log.AmqpTransactionDischargeException( + ServiceBusEventSource.Log.TransactionDischargeException( _transactionId, AmqpTransactionId, exception); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Client/ServiceBusClient.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Client/ServiceBusClient.cs index c879e0b7e812..cc7cc195225b 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Client/ServiceBusClient.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Client/ServiceBusClient.cs @@ -25,7 +25,7 @@ public class ServiceBusClient : IAsyncDisposable /// to be similar to {yournamespace}.servicebus.windows.net. /// /// - public string FullyQualifiedNamespace { get; } + public string FullyQualifiedNamespace => Connection.FullyQualifiedNamespace; /// /// Indicates whether or not this has been disposed. @@ -52,6 +52,12 @@ public class ServiceBusClient : IAsyncDisposable /// private ServiceBusClientOptions Options { get; set; } + /// + /// The instance of which can be mocked for testing. + /// + /// + internal ServiceBusEventSource Logger { get; set; } = ServiceBusEventSource.Log; + /// /// Performs the task needed to clean up resources used by the , /// including ensuring that the connection itself has been closed. @@ -61,7 +67,7 @@ public class ServiceBusClient : IAsyncDisposable [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Justification = "This signature must match the IAsyncDisposable interface.")] public virtual async ValueTask DisposeAsync() { - ServiceBusEventSource.Log.ClientDisposeStart(typeof(ServiceBusConnection), Identifier); + Logger.ClientDisposeStart(typeof(ServiceBusClient), Identifier); IsDisposed = true; try { @@ -69,12 +75,12 @@ public virtual async ValueTask DisposeAsync() } catch (Exception ex) { - ServiceBusEventSource.Log.ClientDisposeException(typeof(ServiceBusConnection), Identifier, ex); + Logger.ClientDisposeException(typeof(ServiceBusClient), Identifier, ex); throw; } finally { - ServiceBusEventSource.Log.ClientDisposeComplete(typeof(ServiceBusConnection), Identifier); + Logger.ClientDisposeComplete(typeof(ServiceBusClient), Identifier); } } @@ -124,8 +130,10 @@ public ServiceBusClient(string connectionString) : public ServiceBusClient(string connectionString, ServiceBusClientOptions options) { Connection = new ServiceBusConnection(connectionString, options); + Logger.ClientCreateStart(typeof(ServiceBusClient), FullyQualifiedNamespace); Options = Connection.Options; - Identifier = DiagnosticUtilities.GenerateIdentifier(Connection.FullyQualifiedNamespace); + Identifier = DiagnosticUtilities.GenerateIdentifier(FullyQualifiedNamespace); + Logger.ClientCreateComplete(typeof(ServiceBusClient), Identifier); } /// @@ -153,12 +161,14 @@ public ServiceBusClient( TokenCredential credential, ServiceBusClientOptions options) { + Logger.ClientCreateStart(typeof(ServiceBusClient), fullyQualifiedNamespace); Identifier = DiagnosticUtilities.GenerateIdentifier(fullyQualifiedNamespace); Connection = new ServiceBusConnection( fullyQualifiedNamespace, credential, options); Options = Connection.Options; + Logger.ClientCreateComplete(typeof(ServiceBusClient), Identifier); } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportClient.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportClient.cs index 1e1f9331f69f..ad12b5467071 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportClient.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportClient.cs @@ -44,10 +44,11 @@ internal abstract class TransportClient : IAsyncDisposable /// The entity path to send the message to. /// The entity path to route the message through. Useful when using transactions. /// The policy which governs retry behavior and try timeouts. + /// The identifier for the sender. /// /// A configured in the requested manner. /// - public abstract TransportSender CreateSender(string entityPath, string viaEntityPath, ServiceBusRetryPolicy retryPolicy); + public abstract TransportSender CreateSender(string entityPath, string viaEntityPath, ServiceBusRetryPolicy retryPolicy, string identifier); /// /// Creates a receiver strongly aligned with the active protocol and transport, responsible @@ -80,12 +81,14 @@ public abstract TransportReceiver CreateReceiver( /// /// The path of the Service Bus subscription to which the rule manager is bound. /// The policy which governs retry behavior and try timeouts. + /// The identifier for the rule manager. /// /// A configured in the requested manner. /// public abstract TransportRuleManager CreateRuleManager( string subscriptionPath, - ServiceBusRetryPolicy retryPolicy); + ServiceBusRetryPolicy retryPolicy, + string identifier); /// /// Closes the connection to the transport client instance. diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticExtensions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticExtensions.cs new file mode 100644 index 000000000000..db3bb7b7170c --- /dev/null +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticExtensions.cs @@ -0,0 +1,16 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.Text; + +namespace Azure.Messaging.ServiceBus.Diagnostics +{ + internal static class DiagnosticExtensions + { + public static string GetAsciiString(this ArraySegment arraySegment) + { + return arraySegment.Array == null ? string.Empty : Encoding.ASCII.GetString(arraySegment.Array, arraySegment.Offset, arraySegment.Count); + } + } +} diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticUtilities.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticUtilities.cs index 776213033ad7..d59e255fb69c 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticUtilities.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/DiagnosticUtilities.cs @@ -2,8 +2,6 @@ // Licensed under the MIT License. using System; -using System.Collections.Generic; -using System.Text; namespace Azure.Messaging.ServiceBus.Diagnostics { diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs index 410fe23bb9f1..90ea5dc71f91 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs @@ -4,8 +4,9 @@ using System; using System.Collections.Generic; using System.Diagnostics.Tracing; -using System.Linq; -using Azure.Messaging.ServiceBus.Core; +using System.Reflection; +using System.Threading.Tasks; +using Azure.Core.Diagnostics; using Azure.Messaging.ServiceBus.Primitives; using Microsoft.Azure.Amqp; @@ -20,771 +21,1256 @@ namespace Azure.Messaging.ServiceBus.Diagnostics /// When defining Start/Stop tasks, it is highly recommended that the /// the StopEvent.Id must be exactly StartEvent.Id + 1. /// - /// - [EventSource(Name = "Azure-Messaging-ServiceBus")] - internal sealed class ServiceBusEventSource : EventSource + [EventSource(Name = EventSourceName)] + internal class ServiceBusEventSource : EventSource { + /// The name to use for the event source. + private const string EventSourceName = "Azure-Messaging-ServiceBus"; + /// /// Provides a singleton instance of the event source for callers to /// use for logging. /// - /// - public static ServiceBusEventSource Log { get; } = new ServiceBusEventSource(); + public static ServiceBusEventSource Log { get; } = new ServiceBusEventSource(EventSourceName); /// - /// Prevents an instance of the class from being created - /// outside the scope of the instance. + /// Prevents an instance of the class from being + /// created outside the scope of the instance, as well as setting up the + /// integration with AzureEventSourceListenter. /// - /// - private ServiceBusEventSource() + private ServiceBusEventSource(string eventSourceName) : base(eventSourceName, EventSourceSettings.Default, AzureEventSourceListener.TraitName, AzureEventSourceListener.TraitValue) { } - [Event(1, Level = EventLevel.Informational, Message = "{0}: SendAsync start. MessageCount = {1}")] - public void SendMessageStart(string identifier, int messageCount) + // parameterless constructor for mocking + internal ServiceBusEventSource() { } + + #region event constants + // event constants should not be changed + internal const int SendMessageStartEvent = 1; + internal const int SendMessageCompleteEvent = 2; + internal const int SendMessageExceptionEvent = 3; + + internal const int CreateMessageBatchStartEvent = 4; + internal const int CreateMessageBatchCompleteEvent = 5; + internal const int CreateMessageBatchExceptionEvent = 6; + + internal const int ReceiveMessageStartEvent = 7; + internal const int ReceiveMessageCompleteEvent = 8; + internal const int ReceiveMessageExceptionEvent = 9; + + internal const int ScheduleMessageStartEvent = 10; + internal const int ScheduleMessageCompleteEvent = 11; + internal const int ScheduleMessageExceptionEvent = 12; + + internal const int CancelScheduledMessageStartEvent = 13; + internal const int CancelScheduledMessageCompleteEvent = 14; + internal const int CancelScheduledMessageExceptionEvent = 15; + + internal const int CompleteMessageStartEvent = 16; + internal const int CompleteMessageCompleteEvent = 17; + internal const int CompleteMessageExceptionEvent = 18; + + internal const int DeferMessageStartEvent = 19; + internal const int DeferMessageCompleteEvent = 20; + internal const int DeferMessageExceptionEvent = 21; + + internal const int AbandonMessageStartEvent = 22; + internal const int AbandonMessageCompleteEvent = 23; + internal const int AbandonMessageExceptionEvent = 24; + + internal const int DeadLetterMessageStartEvent = 25; + internal const int DeadLetterMessageCompleteEvent = 26; + internal const int DeadLetterMessageExceptionEvent = 27; + + internal const int PeekMessageStartEvent = 28; + internal const int PeekMessageCompleteEvent = 29; + internal const int PeekMessageExceptionEvent = 30; + + internal const int RenewMessageLockStartEvent = 31; + internal const int RenewMessageLockCompleteEvent = 32; + internal const int RenewMessageLockExceptionEvent = 33; + + internal const int ReceiveDeferredMessageStartEvent = 34; + internal const int ReceiveDeferredMessageCompleteEvent = 35; + internal const int ReceiveDeferredMessageExceptionEvent = 36; + + internal const int LinkStateLostEvent = 37; + internal const int SessionReceiverLinkClosedEvent = 38; + internal const int AmqpLinkRefreshStartEvent = 39; + internal const int AmqpLinkRefreshCompleteEvent = 40; + internal const int AmqpLinkRefreshExceptionEvent = 41; + internal const int RunOperationExceptionEvent = 43; + + internal const int ClientDisposeStartEvent = 44; + internal const int ClientDisposeCompleteEvent = 45; + internal const int ClientDisposeExceptionEvent = 46; + + internal const int RenewSessionLockStartEvent = 47; + internal const int RenewSessionLockCompleteEvent = 48; + internal const int RenewSessionLockExceptionEvent = 49; + + internal const int StartProcessingStartEvent = 50; + internal const int StartProcessingCompleteEvent = 51; + internal const int StartProcessingExceptionEvent = 52; + + internal const int StopProcessingStartEvent = 53; + internal const int StopProcessingCompleteEvent = 54; + internal const int StopProcessingExceptionEvent = 55; + + internal const int ProcessorRenewMessageLockStartEvent = 56; + internal const int ProcessorRenewMessageLockCompleteEvent = 57; + internal const int ProcessorRenewMessageLockExceptionEvent = 58; + + internal const int ProcessorRenewSessionLockStartEvent = 59; + internal const int ProcessorRenewSessionLockCompleteEvent = 60; + internal const int ProcessorRenewSessionLockExceptionEvent = 61; + + internal const int GetSessionStateStartEvent = 62; + internal const int GetSessionStateCompleteEvent = 63; + internal const int GetSessionStateExceptionEvent = 64; + + internal const int SetSessionStateStartEvent = 65; + internal const int SetSessionStateCompleteEvent = 66; + internal const int SetSessionStateExceptionEvent = 67; + + internal const int AddRuleStartEvent = 68; + internal const int AddRuleCompleteEvent = 69; + internal const int AddRuleExceptionEvent = 70; + + internal const int RemoveRuleStartEvent = 71; + internal const int RemoveRuleCompleteEvent = 72; + internal const int RemoveRuleExceptionEvent = 73; + + internal const int GetRuleStartEvent = 74; + internal const int GetRuleCompleteEvent = 75; + internal const int GetRuleExceptionEvent = 76; + + internal const int ClientCreateStartEvent = 77; + internal const int ClientCreateCompleteEvent = 78; + internal const int ClientCreateExceptionEvent = 79; + + internal const int CreateSendLinkStartEvent = 80; + internal const int CreateSendLinkCompleteEvent = 81; + internal const int CreateSendLinkExceptionEvent = 82; + + internal const int CreateReceiveLinkStartEvent = 83; + internal const int CreateReceiveLinkCompleteEvent = 84; + internal const int CreateReceiveLinkExceptionEvent = 85; + + internal const int CreateManagementLinkStartEvent = 86; + internal const int CreateManagementLinkCompleteEvent = 87; + internal const int CreateManagementLinkExceptionEvent = 88; + + internal const int TransactionInitializationExceptionEvent = 89; + internal const int TransactionDeclaredEvent = 90; + internal const int TransactionDischargedEvent = 91; + internal const int TransactionDischargedExceptionEvent = 92; + internal const int CreateControllerExceptionEvent = 93; + + internal const int ProcessorErrorHandlerThrewExceptionEvent = 94; + internal const int ScheduleTaskFailedEvent = 95; + internal const int ManagementSerializedExceptionEvent = 96; + + + #endregion + // add new event numbers here incrementing from previous + + #region Sending + [Event(SendMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: SendAsync start. MessageCount = {1}")] + public virtual void SendMessageStart(string identifier, int messageCount) { if (IsEnabled()) { - WriteEvent(1, identifier, messageCount); + WriteEvent(SendMessageStartEvent, identifier, messageCount); } } - [Event(2, Level = EventLevel.Informational, Message = "{0}: SendAsync done.")] - public void SendMessageComplete(string identifier) + [Event(SendMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: SendAsync done.")] + public virtual void SendMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(2, identifier); + WriteEvent(SendMessageCompleteEvent, identifier); } } - [Event(3, Level = EventLevel.Error, Message = "{0}: SendAsync Exception: {1}.")] - public void SendMessageException(string identifier, Exception exception) + [Event(SendMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: SendAsync Exception: {1}.")] + public virtual void SendMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(3, identifier, exception.ToString()); + WriteEvent(SendMessageExceptionEvent, identifier, exception); } } - [Event(4, Level = EventLevel.Informational, Message = "{0}: CreateBatchAsync start.")] - public void CreateMessageBatchStart(string identifier) + [Event(CreateMessageBatchStartEvent, Level = EventLevel.Informational, Message = "{0}: CreateBatchAsync start.")] + public virtual void CreateMessageBatchStart(string identifier) { if (IsEnabled()) { - WriteEvent(4, identifier); + WriteEvent(CreateMessageBatchStartEvent, identifier); } } - [Event(5, Level = EventLevel.Informational, Message = "{0}: CreateBatchAsync done.")] - public void CreateMessageBatchComplete(string identifier) + [Event(CreateMessageBatchCompleteEvent, Level = EventLevel.Informational, Message = "{0}: CreateBatchAsync done.")] + public virtual void CreateMessageBatchComplete(string identifier) { if (IsEnabled()) { - WriteEvent(5, identifier); + WriteEvent(CreateMessageBatchCompleteEvent, identifier); } } - [Event(6, Level = EventLevel.Error, Message = "{0}: CreateBatchAsync Exception: {1}.")] - public void CreateMessageBatchException(string identifier, Exception exception) + [Event(CreateMessageBatchExceptionEvent, Level = EventLevel.Error, Message = "{0}: CreateBatchAsync Exception: {1}.")] + public virtual void CreateMessageBatchException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(6, identifier, exception.ToString()); + WriteEvent(CreateMessageBatchExceptionEvent, identifier, exception); } } - [Event(7, Level = EventLevel.Informational, Message = "{0}: ReceiveBatchAsync start. MessageCount = {1}")] - public void ReceiveMessageStart(string identifier, int messageCount) + #endregion + + #region Receiving + + [Event(ReceiveMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ReceiveBatchAsync start. MessageCount = {1}")] + public virtual void ReceiveMessageStart(string identifier, int messageCount) { if (IsEnabled()) { - WriteEvent(7, identifier, messageCount); + WriteEvent(ReceiveMessageStartEvent, identifier, messageCount); } } - [Event(8, Level = EventLevel.Informational, Message = "{0}: ReceiveBatchAsync done. Received '{1}' messages")] - public void ReceiveMessageComplete(string identifier, int messageCount) + [Event(ReceiveMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: ReceiveBatchAsync done. Received '{1}' messages")] + public virtual void ReceiveMessageComplete( + string identifier, + int messageCount) { if (IsEnabled()) { - WriteEvent(8, identifier, messageCount); + WriteEvent(ReceiveMessageCompleteEvent, identifier, messageCount); } } - [Event(9, Level = EventLevel.Error, Message = "{0}: ReceiveBatchAsync Exception: {1}.")] - public void ReceiveMessageException(string clientId, Exception exception) + [Event(ReceiveMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: ReceiveBatchAsync Exception: {1}.")] + public virtual void ReceiveMessageException( + string clientId, + string exception) { if (IsEnabled()) { - WriteEvent(9, clientId, exception.ToString()); + WriteEvent(ReceiveMessageExceptionEvent, clientId, exception); } } - [Event(10, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync start. ScheduleTimeUtc = {1}")] - public void ScheduleMessageStart(string identifier, DateTimeOffset scheduledEnqueueTime) + [Event(ReceiveDeferredMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync start. MessageCount = {1}, LockTokens = {2}")] + public void ReceiveDeferredMessageStartCore(string identifier, int messageCount, string sequenceNumbers) + { + WriteEvent(ReceiveDeferredMessageStartEvent, identifier, messageCount, sequenceNumbers); + } + + [NonEvent] + public virtual void ReceiveDeferredMessageStart(string identifier, int messageCount, IEnumerable sequenceNumbers) { if (IsEnabled()) { - WriteEvent(10, identifier, scheduledEnqueueTime.ToString()); + var formattedSequenceNumbers = StringUtility.GetFormattedSequenceNumbers(sequenceNumbers); + ReceiveDeferredMessageStartCore(identifier, messageCount, formattedSequenceNumbers); } } - [Event(11, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync done.")] - public void ScheduleMessageComplete(string identifier) + [Event(ReceiveDeferredMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync done. Received '{1}' messages")] + public virtual void ReceiveDeferredMessageComplete(string identifier, int messageCount) { if (IsEnabled()) { - WriteEvent(11, identifier); + WriteEvent(ReceiveDeferredMessageCompleteEvent, identifier, messageCount); } } - [Event(12, Level = EventLevel.Error, Message = "{0}: ScheduleMessageAsync Exception: {1}.")] - public void ScheduleMessageException(string identifier, Exception exception) + [Event(ReceiveDeferredMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: ReceiveDeferredMessageAsync Exception: {1}.")] + public virtual void ReceiveDeferredMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(12, identifier, exception.ToString()); + WriteEvent(ReceiveDeferredMessageExceptionEvent, identifier, exception); } } + #endregion - [Event(13, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync start. SequenceNumber = {1}")] - public void CancelScheduledMessageStart(string identifier, long sequenceNumber) + #region Peeking + [Event(PeekMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: MessagePeekAsync start. SequenceNumber = {1}, MessageCount = {2}")] + public virtual void PeekMessageStart(string identifier, long? sequenceNumber, int messageCount) { if (IsEnabled()) { - WriteEvent(13, identifier, sequenceNumber); + WriteEvent(PeekMessageStartEvent, identifier, sequenceNumber, messageCount); } } - [Event(14, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync done.")] - public void CancelScheduledMessageComplete(string identifier) + [Event(PeekMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: MessagePeekAsync done. Peeked '{1}' messages")] + public virtual void PeekMessageComplete(string identifier, int messageCount) { if (IsEnabled()) { - WriteEvent(14, identifier); + WriteEvent(PeekMessageCompleteEvent, identifier, messageCount); } } - [Event(15, Level = EventLevel.Error, Message = "{0}: CancelScheduledMessageAsync Exception: {1}.")] - public void CancelScheduledMessageException(string identifier, Exception exception) + [Event(PeekMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: MessagePeekAsync Exception: {1}.")] + public virtual void PeekMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(15, identifier, exception.ToString()); + WriteEvent(PeekMessageExceptionEvent, identifier, exception); } } + #endregion - [Event(16, Level = EventLevel.Informational, Message = "{0}: CompleteAsync start. MessageCount = {1}, LockTokens = {2}")] - public void CompleteMessageStart(string identifier, int messageCount, IList lockTokens) + #region Scheduling + [Event(ScheduleMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync start. ScheduleTimeUtc = {1}")] + public virtual void ScheduleMessageStart(string identifier, string scheduledEnqueueTime) { if (IsEnabled()) { - var formattedLockTokens = StringUtility.GetFormattedLockTokens(lockTokens); - WriteEvent(16, identifier, messageCount, formattedLockTokens); + WriteEvent(ScheduleMessageStartEvent, identifier, scheduledEnqueueTime); } } - [Event(17, Level = EventLevel.Informational, Message = "{0}: CompleteAsync done.")] - public void CompleteMessageComplete(string identifier) + [Event(ScheduleMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync done.")] + public virtual void ScheduleMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(17, identifier); + WriteEvent(ScheduleMessageCompleteEvent, identifier); } } - [Event(18, Level = EventLevel.Error, Message = "{0}: CompleteAsync Exception: {1}.")] - public void CompleteMessageException(string identifier, Exception exception) + [Event(ScheduleMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: ScheduleMessageAsync Exception: {1}.")] + public virtual void ScheduleMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(18, identifier, exception.ToString()); + WriteEvent(ScheduleMessageExceptionEvent, identifier, exception); } } - [Event(19, Level = EventLevel.Informational, Message = "{0}: DeferAsync start. MessageCount = {1}, LockToken = {2}")] - public void DeferMessageStart(string identifier, int messageCount, string lockToken) + [Event(CancelScheduledMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync start. SequenceNumber = {1}")] + public virtual void CancelScheduledMessageStart(string identifier, long sequenceNumber) { if (IsEnabled()) { - WriteEvent(19, identifier, messageCount, lockToken); + WriteEvent(CancelScheduledMessageStartEvent, identifier, sequenceNumber); } } - [Event(20, Level = EventLevel.Informational, Message = "{0}: DeferAsync done.")] - public void DeferMessageComplete(string identifier) + [Event(CancelScheduledMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync done.")] + public virtual void CancelScheduledMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(20, identifier); + WriteEvent(CancelScheduledMessageCompleteEvent, identifier); } } - [Event(21, Level = EventLevel.Error, Message = "{0}: DeferAsync Exception: {1}.")] - public void DeferMessageException(string identifier, Exception exception) + [Event(CancelScheduledMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: CancelScheduledMessageAsync Exception: {1}.")] + public virtual void CancelScheduledMessageException(string identifier, string exception) { - WriteEvent(21, identifier, exception.ToString()); + if (IsEnabled()) + { + WriteEvent(CancelScheduledMessageExceptionEvent, identifier, exception); + } } + #endregion - [Event(22, Level = EventLevel.Informational, Message = "{0}: AbandonAsync start. MessageCount = {1}, LockToken = {2}")] - public void AbandonMessageStart(string identifier, int messageCount, string lockToken) + #region Settlement + [Event(CompleteMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: CompleteAsync start. MessageCount = {1}, LockTokens = {2}")] + public virtual void CompleteMessageStart(string identifier, int messageCount, string lockTokens) { if (IsEnabled()) { - WriteEvent(22, identifier, messageCount, lockToken); + WriteEvent(CompleteMessageStartEvent, identifier, messageCount, lockTokens); } } - [Event(23, Level = EventLevel.Informational, Message = "{0}: AbandonAsync done.")] - public void AbandonMessageComplete(string identifier) + [Event(CompleteMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: CompleteAsync done.")] + public virtual void CompleteMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(17, identifier); + WriteEvent(CompleteMessageCompleteEvent, identifier); } } - [Event(24, Level = EventLevel.Error, Message = "{0}: AbandonAsync Exception: {1}.")] - public void AbandonMessageException(string identifier, Exception exception) + [Event(CompleteMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: CompleteAsync Exception: {1}.")] + public virtual void CompleteMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(24, identifier, exception.ToString()); + WriteEvent(CompleteMessageExceptionEvent, identifier, exception); } } - [Event(25, Level = EventLevel.Informational, Message = "{0}: DeadLetterAsync start. MessageCount = {1}, LockToken = {2}")] - public void DeadLetterMessageStart(string identifier, int messageCount, string lockToken) + [Event(DeferMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: DeferAsync start. MessageCount = {1}, LockToken = {2}")] + public virtual void DeferMessageStart(string identifier, int messageCount, string lockToken) { if (IsEnabled()) { - WriteEvent(25, identifier, messageCount, lockToken); + WriteEvent(DeferMessageStartEvent, identifier, messageCount, lockToken); } } - [Event(26, Level = EventLevel.Informational, Message = "{0}: DeadLetterAsync done.")] - public void DeadLetterMessageComplete(string identifier) + [Event(DeferMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: DeferAsync done.")] + public virtual void DeferMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(26, identifier); + WriteEvent(DeferMessageCompleteEvent, identifier); } } - [Event(27, Level = EventLevel.Error, Message = "{0}: DeadLetterAsync Exception: {1}.")] - public void DeadLetterMessageException(string identifier, Exception exception) + [Event(DeferMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: DeferAsync Exception: {1}.")] + public virtual void DeferMessageException(string identifier, string exception) + { + WriteEvent(DeferMessageExceptionEvent, identifier, exception); + } + + [Event(AbandonMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: AbandonAsync start. MessageCount = {1}, LockToken = {2}")] + public virtual void AbandonMessageStart(string identifier, int messageCount, string lockToken) { if (IsEnabled()) { - WriteEvent(27, identifier, exception.ToString()); + WriteEvent(AbandonMessageStartEvent, identifier, messageCount, lockToken); } } - [Event(28, Level = EventLevel.Informational, Message = "{0}: MessagePeekAsync start. SequenceNumber = {1}, MessageCount = {2}")] - public void PeekMessageStart(string identifier, long? sequenceNumber, int messageCount) + [Event(AbandonMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: AbandonAsync done.")] + public virtual void AbandonMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(28, identifier, sequenceNumber, messageCount); + WriteEvent(AbandonMessageCompleteEvent, identifier); } } - [Event(29, Level = EventLevel.Informational, Message = "{0}: MessagePeekAsync done. Peeked '{1}' messages")] - public void PeekMessageComplete(string identifier, int messageCount) + [Event(AbandonMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: AbandonAsync Exception: {1}.")] + public virtual void AbandonMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(29, identifier, messageCount); + WriteEvent(AbandonMessageExceptionEvent, identifier, exception); } } - [Event(30, Level = EventLevel.Error, Message = "{0}: MessagePeekAsync Exception: {1}.")] - public void PeekMessageException(string identifier, Exception exception) + [Event(DeadLetterMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: DeadLetterAsync start. MessageCount = {1}, LockToken = {2}")] + public virtual void DeadLetterMessageStart(string identifier, int messageCount, string lockToken) { if (IsEnabled()) { - WriteEvent(30, identifier, exception.ToString()); + WriteEvent(DeadLetterMessageStartEvent, identifier, messageCount, lockToken); } } - [Event(31, Level = EventLevel.Informational, Message = "{0}: RenewLockAsync start. MessageCount = {1}, LockToken = {2}")] - public void RenewMessageLockStart(string identifier, int messageCount, string lockToken) + [Event(DeadLetterMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: DeadLetterAsync done.")] + public virtual void DeadLetterMessageComplete(string identifier) { if (IsEnabled()) { - WriteEvent(31, identifier, messageCount, lockToken); + WriteEvent(DeadLetterMessageCompleteEvent, identifier); } } - [Event(32, Level = EventLevel.Informational, Message = "{0}: RenewLockAsync done.")] - public void RenewMessageLockComplete(string identifier) + [Event(DeadLetterMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: DeadLetterAsync Exception: {1}.")] + public virtual void DeadLetterMessageException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(32, identifier); + WriteEvent(DeadLetterMessageExceptionEvent, identifier, exception); } } + #endregion - [Event(33, Level = EventLevel.Error, Message = "{0}: RenewLockAsync Exception: {1}.")] - public void RenewMessageLockException(string identifier, Exception exception) + #region Lock renewal + [Event(RenewMessageLockStartEvent, Level = EventLevel.Informational, Message = "{0}: RenewLockAsync start. MessageCount = {1}, LockToken = {2}")] + public virtual void RenewMessageLockStart(string identifier, int messageCount, string lockToken) { if (IsEnabled()) { - WriteEvent(33, identifier, exception.ToString()); + WriteEvent(RenewMessageLockStartEvent, identifier, messageCount, lockToken); } } - [Event(34, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync start. MessageCount = {1}, LockTokens = {2}")] - public void ReceiveDeferredMessageStart(string identifier, int messageCount, IEnumerable sequenceNumbers) + [Event(RenewMessageLockCompleteEvent, Level = EventLevel.Informational, Message = "{0}: RenewLockAsync done.")] + public virtual void RenewMessageLockComplete(string identifier) { if (IsEnabled()) { - var formattedSequenceNumbers = StringUtility.GetFormattedSequenceNumbers(sequenceNumbers); - WriteEvent(34, identifier, messageCount, formattedSequenceNumbers); + WriteEvent(RenewMessageLockCompleteEvent, identifier); } } - [Event(35, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync done. Received '{1}' messages")] - public void ReceiveDeferredMessageStop(string identifier, int messageCount) + [Event(RenewMessageLockExceptionEvent, Level = EventLevel.Error, Message = "{0}: RenewLockAsync Exception: {1}.")] + public virtual void RenewMessageLockException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(35, identifier, messageCount); + WriteEvent(RenewMessageLockExceptionEvent, identifier, exception); } } - [Event(36, Level = EventLevel.Error, Message = "{0}: ReceiveDeferredMessageAsync Exception: {1}.")] - public void ReceiveDeferredMessageException(string identifier, Exception exception) + [Event(RenewSessionLockStartEvent, Level = EventLevel.Informational, Message = "{0}: RenewSessionLockAsync start. SessionId = {1}")] + public virtual void RenewSessionLockStart(string identifier, string sessionId) { if (IsEnabled()) { - WriteEvent(36, identifier, exception, ToString()); + WriteEvent(RenewSessionLockStartEvent, identifier, sessionId); } } - [Event(37, Level = EventLevel.Error, Message = "Link state lost. Throwing LockLostException for identifier: {0}, receiveLinkName: {1}, receiveLinkState: {2}, isSessionReceiver: {3}, exception: {4}.")] - public void LinkStateLost(string identifier, string receiveLinkName, AmqpObjectState receiveLinkState, bool isSessionReceiver, Exception exception) + [Event(RenewSessionLockCompleteEvent, Level = EventLevel.Informational, Message = "{0}: RenewSessionLockAsync done.")] + public virtual void RenewSessionLockComplete(string identifier) { if (IsEnabled()) { - WriteEvent(37, identifier, receiveLinkName, receiveLinkState.ToString(), isSessionReceiver, exception.ToString()); + WriteEvent(RenewSessionLockCompleteEvent, identifier); } } - [Event(38, Level = EventLevel.Error, Message = "SessionReceiver Link Closed. identifier: {0}, SessionId: {1}, linkException: {2}.")] - public void SessionReceiverLinkClosed(string identifier, string sessionId, Exception linkException) + [Event(RenewSessionLockExceptionEvent, Level = EventLevel.Error, Message = "{0}: RenewSessionLockAsync Exception: {1}.")] + public virtual void RenewSessionLockException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(38, identifier, sessionId, linkException.ToString()); + WriteEvent(RenewSessionLockExceptionEvent, identifier, exception); } } + #endregion - /// - /// Indicates that refreshing authorization for an AMQP link has started. - /// - /// - /// The name of the Entity that the link is associated with. - /// The service endpoint that the link is bound to for communication. - /// - [Event(39, Level = EventLevel.Informational, Message = "Beginning refresh of AMQP link authorization for Identifier: {0} (Service Endpoint: '{1}').")] - public void AmqpLinkAuthorizationRefreshStart(string identifier, - string endpoint) + #region Get/Set session state + + [Event(GetSessionStateStartEvent, Level = EventLevel.Informational, Message = "{0}: Session GetStateAsync start. SessionId = {1}")] + public virtual void GetSessionStateStart(string identifiers, string sessionId) { if (IsEnabled()) { - WriteEvent(39, identifier ?? string.Empty, endpoint ?? string.Empty); + WriteEvent(GetSessionStateStartEvent, identifiers, sessionId); } } - /// - /// Indicates that refreshing authorization for an AMQP link has completed. - /// - /// - /// The name of the Entity that the link is associated with. - /// The service endpoint that the link is bound to for communication. - /// - [Event(40, Level = EventLevel.Informational, Message = "Completed refresh of AMQP link authorization for Identifier: {0} (Service Endpoint: '{1}').")] - public void AmqpLinkAuthorizationRefreshComplete(string identifier, - string endpoint) + [Event(GetSessionStateCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Session GetStateAsync done.")] + public virtual void GetSessionStateComplete(string identifier) { if (IsEnabled()) { - WriteEvent(40, identifier ?? string.Empty, endpoint ?? string.Empty); + WriteEvent(GetSessionStateCompleteEvent, identifier); } } - /// - /// Indicates that an exception was encountered while refreshing authorization for an AMQP link has started. - /// - /// - /// The name of the Entity that the link is associated with. - /// The service endpoint that the link is bound to for communication. - /// The message for the exception that occurred. - /// - [Event(41, Level = EventLevel.Error, Message = "An exception occurred while refreshing AMQP link authorization for Identifier: {0} (Service Endpoint: '{1}'). Error Message: '{2}'")] - public void AmqpLinkAuthorizationRefreshError(string identifier, - string endpoint, - string errorMessage) + [Event(GetSessionStateExceptionEvent, Level = EventLevel.Error, Message = "{0}: Session GetStateAsync Exception: {1}.")] + public virtual void GetSessionStateException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(41, identifier ?? string.Empty, endpoint ?? string.Empty, errorMessage ?? string.Empty); + WriteEvent(GetSessionStateExceptionEvent, identifier, exception); } } - /// - /// Indicates that an exception was encountered in an unexpected code path, not directly associated with - /// an Entitys operation. - /// - /// - /// The message for the exception that occurred. - /// - [Event(42, Level = EventLevel.Error, Message = "An unexpected exception was encountered. Error Message: '{0}'")] - public void UnexpectedException(string errorMessage) + [Event(SetSessionStateStartEvent, Level = EventLevel.Informational, Message = "{0}: Session SetStateAsync start. SessionId = {1}")] + public virtual void SetSessionStateStart(string identifiers, string sessionId) { if (IsEnabled()) { - WriteEvent(42, errorMessage); + WriteEvent(SetSessionStateStartEvent, identifiers, sessionId); } } - [Event(43, Level = EventLevel.Warning, Message = "RunOperation encountered an exception and will retry. Exception: {0}")] - public void RunOperationExceptionEncountered(Exception exception) + [Event(SetSessionStateCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Session SetStateAsync done.")] + public virtual void SetSessionStateComplete(string identifier) { if (IsEnabled()) { - WriteEvent(43, exception.ToString()); + WriteEvent(SetSessionStateCompleteEvent, identifier); + } + } + + [Event(SetSessionStateExceptionEvent, Level = EventLevel.Error, Message = "{0}: Session SetStateAsync Exception: {1}.")] + public virtual void SetSessionStateException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(SetSessionStateExceptionEvent, identifier, exception); + } + } + #endregion + + #region Processor + + [Event(StartProcessingStartEvent, Level = EventLevel.Informational, Message = "{0}: StartProcessingAsync start.")] + public virtual void StartProcessingStart(string identifier) + { + if (IsEnabled()) + { + WriteEvent(StartProcessingStartEvent, identifier); + } + } + + [Event(StartProcessingCompleteEvent, Level = EventLevel.Informational, Message = "{0}: StartProcessingAsync done.")] + public virtual void StartProcessingComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(StartProcessingCompleteEvent, identifier); + } + } + + [Event(StartProcessingExceptionEvent, Level = EventLevel.Error, Message = "{0}: StartProcessingAsync Exception: {1}.")] + public virtual void StartProcessingException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(StartProcessingExceptionEvent, identifier, exception); + } + } + + [Event(StopProcessingStartEvent, Level = EventLevel.Informational, Message = "{0}: StopProcessingAsync start.")] + public virtual void StopProcessingStart(string identifier) + { + if (IsEnabled()) + { + WriteEvent(StopProcessingStartEvent, identifier); + } + } + + [Event(StopProcessingCompleteEvent, Level = EventLevel.Informational, Message = "{0}: StopProcessingAsync done.")] + public virtual void StopProcessingComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(StopProcessingCompleteEvent, identifier); + } + } + + [Event(StopProcessingExceptionEvent, Level = EventLevel.Error, Message = "{0}: StopProcessingAsync Exception: {1}.")] + public virtual void StopProcessingException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(StopProcessingExceptionEvent, identifier, exception); + } + } + + [Event(ProcessorRenewMessageLockStartEvent, Level = EventLevel.Informational, Message = "{0}: Processor RenewMessageLock start. MessageCount = {1}, LockToken = {2}")] + public virtual void ProcessorRenewMessageLockStart(string identifier, int messageCount, string lockToken) + { + if (IsEnabled()) + { + WriteEvent(ProcessorRenewMessageLockStartEvent, identifier, messageCount, lockToken); + } + } + + [Event(ProcessorRenewMessageLockCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Processor RenewMessageLock complete.")] + public virtual void ProcessorRenewMessageLockComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(ProcessorRenewMessageLockCompleteEvent, identifier); + } + } + + [Event(ProcessorRenewMessageLockExceptionEvent, Level = EventLevel.Error, Message = "{0}: Processor RenewMessageLock Exception: {1}.")] + public virtual void ProcessorRenewMessageLockException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(ProcessorRenewMessageLockExceptionEvent, identifier, exception); + } + } + + [Event(ProcessorRenewSessionLockStartEvent, Level = EventLevel.Informational, Message = "{0}: Processor RenewSessionLock start. SessionId = {1}")] + public virtual void ProcessorRenewSessionLockStart(string identifier, string sessionId) + { + if (IsEnabled()) + { + WriteEvent(ProcessorRenewSessionLockStartEvent, identifier, sessionId); + } + } + + [Event(ProcessorRenewSessionLockCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Processor RenewSessionLock complete.")] + public virtual void ProcessorRenewSessionLockComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(ProcessorRenewSessionLockCompleteEvent, identifier); + } + } + + [Event(ProcessorRenewSessionLockExceptionEvent, Level = EventLevel.Error, Message = "{0}: Processor RenewSessionLock Exception: {1}.")] + public virtual void ProcessorRenewSessionLockException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(ProcessorRenewSessionLockExceptionEvent, identifier, exception); + } + } + + [Event(ProcessorErrorHandlerThrewExceptionEvent, Level = EventLevel.Error, Message = "ExceptionReceivedHandler threw exception. Exception:{0}")] + public void ProcessorErrorHandlerThrewException(string exception) + { + if (IsEnabled()) + { + WriteEvent(ProcessorErrorHandlerThrewExceptionEvent, exception); + } + } + + + + #endregion region + + #region Rule management + [Event(AddRuleStartEvent, Level = EventLevel.Informational, Message = "{0}: Add rule start. RuleName = {1}")] + public virtual void AddRuleStart(string identifiers, string ruleName) + { + if (IsEnabled()) + { + WriteEvent(AddRuleStartEvent, identifiers, ruleName); + } + } + + [Event(AddRuleCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Add rule done.")] + public virtual void AddRuleComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(AddRuleCompleteEvent, identifier); + } + } + + [Event(AddRuleExceptionEvent, Level = EventLevel.Error, Message = "{0}: Add rule Exception: {1}.")] + public virtual void AddRuleException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(AddRuleExceptionEvent, identifier, exception); + } + } + + [Event(RemoveRuleStartEvent, Level = EventLevel.Informational, Message = "{0}: Remove rule start. RuleName = {1}")] + public virtual void RemoveRuleStart(string identifiers, string ruleName) + { + if (IsEnabled()) + { + WriteEvent(RemoveRuleStartEvent, identifiers, ruleName); + } + } + + [Event(RemoveRuleCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Remove rule done.")] + public virtual void RemoveRuleComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(RemoveRuleCompleteEvent, identifier); + } + } + + [Event(RemoveRuleExceptionEvent, Level = EventLevel.Error, Message = "{0}: Remove rule Exception: {1}.")] + public virtual void RemoveRuleException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(RemoveRuleExceptionEvent, identifier, exception); + } + } + + [Event(GetRuleStartEvent, Level = EventLevel.Informational, Message = "{0}: Get rule start.")] + public virtual void GetRuleStart(string identifiers) + { + if (IsEnabled()) + { + WriteEvent(GetRuleStartEvent, identifiers); + } + } + + [Event(GetRuleCompleteEvent, Level = EventLevel.Informational, Message = "{0}: Get rule done.")] + public virtual void GetRuleComplete(string identifier) + { + if (IsEnabled()) + { + WriteEvent(GetRuleCompleteEvent, identifier); + } + } + + [Event(GetRuleExceptionEvent, Level = EventLevel.Error, Message = "{0}: Get rule Exception: {1}.")] + public virtual void GetRuleException(string identifier, string exception) + { + if (IsEnabled()) + { + WriteEvent(GetRuleExceptionEvent, identifier, exception); + } + } + #endregion + + #region Link lifecycle + [Event(LinkStateLostEvent, Level = EventLevel.Error, Message = "Link state lost. Throwing LockLostException for identifier: {0}, receiveLinkName: {1}, receiveLinkState: {2}, isSessionReceiver: {3}, exception: {4}.")] + public virtual void LinkStateLost(string identifier, string receiveLinkName, string receiveLinkState, bool isSessionReceiver, string exception) + { + if (IsEnabled()) + { + WriteEvent(LinkStateLostEvent, identifier, receiveLinkName, receiveLinkState, isSessionReceiver, exception); + } + } + + [Event(SessionReceiverLinkClosedEvent, Level = EventLevel.Error, Message = "SessionReceiver Link Closed. identifier: {0}, SessionId: {1}, linkException: {2}.")] + public virtual void SessionReceiverLinkClosed(string identifier, string sessionId, string linkException) + { + if (IsEnabled()) + { + WriteEvent(SessionReceiverLinkClosedEvent, identifier, sessionId, linkException); } } /// - /// Indicates that a client is closing, which may correspond to an , - /// , , or . + /// Indicates that refreshing authorization for an AMQP link has started. /// /// - /// The type of client being closed. - /// An identifier to associate with the client. + /// The name of the Entity that the link is associated with. + /// The service endpoint that the link is bound to for communication. /// - [Event(44, Level = EventLevel.Verbose, Message = "Closing an {0} (Identifier '{1}').")] - public void ClientDisposeStart( - Type clientType, - string identifier) + [Event(AmqpLinkRefreshStartEvent, Level = EventLevel.Informational, Message = "Beginning refresh of AMQP link authorization for Identifier: {0} (Service Endpoint: '{1}').")] + public virtual void AmqpLinkAuthorizationRefreshStart( + string identifier, + string endpoint) { if (IsEnabled()) { - WriteEvent(44, clientType.Name, identifier ?? string.Empty); + WriteEvent(AmqpLinkRefreshStartEvent, identifier ?? string.Empty, endpoint ?? string.Empty); } } /// - /// Indicates that a client has been closed, which may correspond to an , - /// , , or EventProcessorClient. + /// Indicates that refreshing authorization for an AMQP link has completed. /// /// - /// The type of client being closed. - /// An identifier to associate with the client. + /// The name of the Entity that the link is associated with. + /// The service endpoint that the link is bound to for communication. /// - [Event(45, Level = EventLevel.Verbose, Message = "An {0} has been closed (Identifier '{1}').")] - public void ClientDisposeComplete( - Type clientType, - string identifier) + [Event(AmqpLinkRefreshCompleteEvent, Level = EventLevel.Informational, Message = "Completed refresh of AMQP link authorization for Identifier: {0} (Service Endpoint: '{1}').")] + public virtual void AmqpLinkAuthorizationRefreshComplete( + string identifier, + string endpoint) { if (IsEnabled()) { - WriteEvent(45, clientType.Name, identifier ?? string.Empty); + WriteEvent(AmqpLinkRefreshCompleteEvent, identifier ?? string.Empty, endpoint ?? string.Empty); } } /// - /// Indicates that an exception was encountered while closing an , - /// , , or EventProcessorClient. + /// Indicates that an exception was encountered while refreshing authorization for an AMQP link has started. /// /// - /// The type of client being closed. - /// An identifier to associate with the client. - /// The message for the exception that occurred. + /// The name of the Entity that the link is associated with. + /// The service endpoint that the link is bound to for communication. + /// The message for the exception that occurred. /// - [Event(46, Level = EventLevel.Error, Message = "An exception occurred while closing an {0} (Identifier '{2}'). Error Message: '{3}'")] - public void ClientDisposeException( - Type clientType, + [Event(AmqpLinkRefreshExceptionEvent, Level = EventLevel.Error, Message = "An exception occurred while refreshing AMQP link authorization for Identifier: {0} (Service Endpoint: '{1}'). Error Message: '{2}'")] + public virtual void AmqpLinkAuthorizationRefreshError( string identifier, - Exception exception) + string endpoint, + string errorMessage) { if (IsEnabled()) { - WriteEvent(46, clientType.Name, identifier, exception.ToString()); + WriteEvent(AmqpLinkRefreshExceptionEvent, identifier ?? string.Empty, endpoint ?? string.Empty, errorMessage ?? string.Empty); } } - [Event(47, Level = EventLevel.Informational, Message = "{0}: RenewSessionLockAsync start. SessionId = {1}")] - public void RenewSessionLockStart(string identifier, string sessionId) + [Event(CreateSendLinkStartEvent, Level = EventLevel.Informational, Message = "Creating send link for Identifier: {0}.")] + public virtual void CreateSendLinkStart( + string identifier) { if (IsEnabled()) { - WriteEvent(47, identifier, sessionId); + WriteEvent(CreateSendLinkStartEvent, identifier); } } - [Event(48, Level = EventLevel.Informational, Message = "{0}: RenewSessionLockAsync done.")] - public void RenewSessionLockComplete(string identifier) + [Event(CreateSendLinkCompleteEvent, Level = EventLevel.Informational, Message = "Send link created for Identifier: {0}.")] + public virtual void CreateSendLinkComplete( + string identifier) { if (IsEnabled()) { - WriteEvent(48, identifier); + WriteEvent(CreateSendLinkCompleteEvent, identifier); } } - [Event(49, Level = EventLevel.Error, Message = "{0}: RenewSessionLockAsync Exception: {1}.")] - public void RenewSessionLockException(string identifier, Exception exception) + [Event(CreateSendLinkExceptionEvent, Level = EventLevel.Error, Message = "An exception occurred while creating send link for Identifier: {0}. Error Message: '{1}'")] + public virtual void CreateSendLinkException( + string identifier, + string exception) { if (IsEnabled()) { - WriteEvent(49, identifier, exception.ToString()); + WriteEvent(CreateSendLinkExceptionEvent, identifier, exception); } } - [Event(50, Level = EventLevel.Informational, Message = "{0}: StartProcessingAsync start.")] - public void StartProcessingStart(string identifier) + [Event(CreateReceiveLinkStartEvent, Level = EventLevel.Informational, Message = "Creating receive link for Identifier: {0}.")] + public virtual void CreateReceiveLinkStart(string identifier) { if (IsEnabled()) { - WriteEvent(50, identifier); + WriteEvent(CreateReceiveLinkStartEvent, identifier); } } - [Event(51, Level = EventLevel.Informational, Message = "{0}: StartProcessingAsync done.")] - public void StartProcessingComplete(string identifier) + [Event(CreateReceiveLinkCompleteEvent, Level = EventLevel.Informational, Message = "Receive link created for Identifier: {0}.")] + public virtual void CreateReceiveLinkComplete(string identifier) { if (IsEnabled()) { - WriteEvent(51, identifier); + WriteEvent(CreateReceiveLinkCompleteEvent, identifier); } } - [Event(52, Level = EventLevel.Error, Message = "{0}: StartProcessingAsync Exception: {1}.")] - public void StartProcessingException(string identifier, Exception exception) + [Event(CreateReceiveLinkExceptionEvent, Level = EventLevel.Error, Message = "An exception occurred while creating receive link for Identifier: {0}. Error Message: '{1}'")] + public virtual void CreateReceiveLinkException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(52, identifier, exception.ToString()); + WriteEvent(CreateReceiveLinkExceptionEvent, identifier, exception); } } - [Event(53, Level = EventLevel.Informational, Message = "{0}: StopProcessingAsync start.")] - public void StopProcessingStart(string identifier) + [Event(CreateManagementLinkStartEvent, Level = EventLevel.Informational, Message = "Creating management link for Identifier: {0}.")] + public virtual void CreateManagementLinkStart(string identifier) { if (IsEnabled()) { - WriteEvent(53, identifier); + WriteEvent(CreateManagementLinkStartEvent, identifier); } } - [Event(54, Level = EventLevel.Informational, Message = "{0}: StopProcessingAsync done.")] - public void StopProcessingComplete(string identifier) + [Event(CreateManagementLinkCompleteEvent, Level = EventLevel.Informational, Message = "Management link created for Identifier: {0}.")] + public virtual void CreateManagementLinkComplete(string identifier) { if (IsEnabled()) { - WriteEvent(54, identifier); + WriteEvent(CreateManagementLinkCompleteEvent, identifier); } } - [Event(55, Level = EventLevel.Error, Message = "{0}: StopProcessingAsync Exception: {1}.")] - public void StopProcessingException(string identifier, Exception exception) + [Event(CreateManagementLinkExceptionEvent, Level = EventLevel.Error, Message = "An exception occurred while creating management link for Identifier: {0}. Error Message: '{1}'")] + public virtual void CreateManagementLinkException(string identifier, string exception) { if (IsEnabled()) { - WriteEvent(55, identifier, exception.ToString()); + WriteEvent(CreateManagementLinkExceptionEvent, identifier, exception); } } + #endregion + + #region Retries - [Event(56, Level = EventLevel.Informational, Message = "{0}: Processor RenewMessageLock start. MessageCount = {1}, LockToken = {2}")] - public void ProcessorRenewMessageLockStart(string identifier, int messageCount, string lockToken) + [Event(RunOperationExceptionEvent, Level = EventLevel.Warning, Message = "RunOperation encountered an exception and will retry. Exception: {0}")] + public virtual void RunOperationExceptionEncountered(string exception) { if (IsEnabled()) { - WriteEvent(56, identifier, messageCount, lockToken); + WriteEvent(RunOperationExceptionEvent, exception); } } + #endregion - [Event(57, Level = EventLevel.Informational, Message = "{0}: Processor RenewMessageLock complete.")] - public void ProcessorRenewMessageLockComplete(string identifier) + #region Client lifecycle + + /// + /// Indicates that a client is being created, which may correspond to + /// a , , + /// or . + /// + /// + /// The type of client being created. + /// The namespace for the client. + /// The entity name for the client. + [NonEvent] + public virtual void ClientCreateStart( + Type clientType, + string fullyQualifiedNamespace, + string entityName = default) { if (IsEnabled()) { - WriteEvent(57, identifier); + ClientCreateStartCore(clientType.Name, fullyQualifiedNamespace, entityName ?? string.Empty); } } - [Event(58, Level = EventLevel.Error, Message = "{0}: Processor RenewMessageLock Exception: {1}.")] - public void ProcesserRenewMessageLockException(string identifier, Exception exception) + [Event(ClientCreateStartEvent, Level = EventLevel.Verbose, Message = "Creating a {0} (Namespace: '{1}', Entity name: '{2}'")] + public virtual void ClientCreateStartCore( + string clientType, + string fullyQualifiedNamespace, + string entityName = default) { if (IsEnabled()) { - WriteEvent(58, identifier, exception.ToString()); + WriteEvent(ClientCreateStartEvent, clientType, fullyQualifiedNamespace, entityName); } } - [Event(59, Level = EventLevel.Informational, Message = "{0}: Processor RenewSessionLock start. SessionId = {1}")] - public void ProcessorRenewSessionLockStart(string identifier, string sessionId) + /// + /// Indicates that a client has been created, which may correspond to a + /// , , or + /// . + /// + /// + /// The type of client being closed. + /// An identifier to associate with the client. + /// + [NonEvent] + public virtual void ClientCreateComplete( + Type clientType, + string identifier) { if (IsEnabled()) { - WriteEvent(59, identifier, sessionId); + ClientCreateCompleteCore(clientType.Name, identifier ?? string.Empty); } } - [Event(60, Level = EventLevel.Informational, Message = "{0}: Processor RenewSessionLock complete.")] - public void ProcessorRenewSessionLockComplete(string identifier) + [Event(ClientCreateCompleteEvent, Level = EventLevel.Verbose, Message = "A {0} has been created (Identifier '{1}').")] + public virtual void ClientCreateCompleteCore( + string clientType, + string identifier) { if (IsEnabled()) { - WriteEvent(60, identifier); + WriteEvent(ClientCreateCompleteEvent, clientType, identifier ?? string.Empty); } } - [Event(61, Level = EventLevel.Error, Message = "{0}: Processor RenewSessionLock Exception: {1}.")] - public void ProcessorRenewSessionLockException(string identifier, Exception exception) + /// + /// Indicates that an exception was encountered while creating + /// , , or + /// . + /// + /// + /// The type of client being closed. + /// The namespace for the client. + /// The entity path for the client. + /// The message for the exception that occurred. + /// + [NonEvent] + public virtual void ClientCreateException( + Type clientType, + string fullyQualifiedNamespace, + string entityPath, + Exception exception) { if (IsEnabled()) { - WriteEvent(61, identifier, exception.ToString()); + ClientCreateExceptionCore(clientType.Name, fullyQualifiedNamespace, entityPath, exception.ToString()); } } - [Event(62, Level = EventLevel.Informational, Message = "{0}: Session GetStateAsync start. SessionId = {1}")] - public void GetSessionStateStart(string identifiers, string sessionId) + [Event(ClientCreateExceptionEvent, Level = EventLevel.Error, Message = "An exception occurred while creating a {0} (Namespace '{1}', Entity path '{2}'). Error Message: '{3}'")] + public virtual void ClientCreateExceptionCore( + string clientType, + string fullyQualifiedNamespace, + string entityPath, + string exception) { if (IsEnabled()) { - WriteEvent(62, identifiers, sessionId); + WriteEvent(ClientCreateExceptionEvent, clientType, fullyQualifiedNamespace, entityPath, exception); } } - [Event(63, Level = EventLevel.Informational, Message = "{0}: Session GetStateAsync done.")] - public void GetSessionStateComplete(string identifier) + /// + /// Indicates that a client is closing, which may correspond to + /// a , , + /// or . + /// + /// + /// The type of client being closed. + /// An identifier to associate with the client. + /// + [NonEvent] + public virtual void ClientDisposeStart( + Type clientType, + string identifier) { if (IsEnabled()) { - WriteEvent(63, identifier); + ClientDisposeStartCore(clientType.Name, identifier ?? string.Empty); } } - [Event(64, Level = EventLevel.Error, Message = "{0}: Session GetStateAsync Exception: {1}.")] - public void GetSessionStateException(string identifier, Exception exception) + [Event(ClientDisposeStartEvent, Level = EventLevel.Verbose, Message = "Closing a {0} (Identifier '{1}').")] + public virtual void ClientDisposeStartCore( + string clientType, + string identifier) { if (IsEnabled()) { - WriteEvent(64, identifier, exception.ToString()); + WriteEvent(ClientDisposeStartEvent, clientType, identifier); } } - [Event(65, Level = EventLevel.Informational, Message = "{0}: Session SetStateAsync start. SessionId = {1}")] - public void SetSessionStateStart(string identifiers, string sessionId) + /// + /// Indicates that a client has been closed, which may correspond to an , + /// , , or EventProcessorClient. + /// + /// + /// The type of client being closed. + /// An identifier to associate with the client. + /// + [NonEvent] + public virtual void ClientDisposeComplete( + Type clientType, + string identifier) { if (IsEnabled()) { - WriteEvent(65, identifiers, sessionId); + ClientDisposeCompleteCore(clientType.Name, identifier ?? string.Empty); } } - [Event(66, Level = EventLevel.Informational, Message = "{0}: Session SetStateAsync done.")] - public void SetSessionStateComplete(string identifier) + [Event(ClientDisposeCompleteEvent, Level = EventLevel.Verbose, Message = "A {0} has been closed (Identifier '{1}').")] + public virtual void ClientDisposeCompleteCore( + string clientType, + string identifier) { if (IsEnabled()) { - WriteEvent(66, identifier); + WriteEvent(ClientDisposeCompleteEvent, clientType, identifier); } } - [Event(67, Level = EventLevel.Error, Message = "{0}: Session SetStateAsync Exception: {1}.")] - public void SetSessionStateException(string identifier, Exception exception) + /// + /// Indicates that an exception was encountered while closing an , + /// , , or EventProcessorClient. + /// + /// + /// The type of client being closed. + /// An identifier to associate with the client. + /// The message for the exception that occurred. + /// + [NonEvent] + public virtual void ClientDisposeException( + Type clientType, + string identifier, + Exception exception) { if (IsEnabled()) { - WriteEvent(67, identifier, exception.ToString()); + ClientDisposeExceptionCore(clientType.Name, identifier ?? string.Empty, exception.ToString()); } } - [Event(68, Level = EventLevel.Informational, Message = "{0}: Add rule start. RuleName = {1}")] - public void AddRuleStart(string identifiers, string ruleName) + [Event(ClientDisposeExceptionEvent, Level = EventLevel.Error, Message = "An exception occurred while closing a {0} (Identifier '{1}'). Error Message: '{2}'")] + public virtual void ClientDisposeExceptionCore( + string clientType, + string identifier, + string exception) { if (IsEnabled()) { - WriteEvent(68, identifiers, ruleName); + WriteEvent(ClientDisposeExceptionEvent, clientType, identifier, exception); } } + #endregion - [Event(69, Level = EventLevel.Informational, Message = "{0}: Add rule done.")] - public void AddRuleComplete(string identifier) + #region transactions + [Event(TransactionInitializationExceptionEvent, Level = EventLevel.Error, Message = "AmqpTransactionInitializeException for TransactionId: {0} Exception: {1}.")] + public void TransactionInitializeException(string transactionId, string exception) { if (IsEnabled()) { - WriteEvent(69, identifier); + WriteEvent(TransactionInitializationExceptionEvent, transactionId, exception); } } - [Event(70, Level = EventLevel.Error, Message = "{0}: Add rule Exception: {1}.")] - public void AddRuleException(string identifier, Exception exception) + [NonEvent] + public void TransactionDeclared(string localTransactionId, ArraySegment amqpTransactionId) { if (IsEnabled()) { - WriteEvent(70, identifier, exception.ToString()); + TransactionDeclared(localTransactionId, amqpTransactionId.GetAsciiString()); } } - [Event(71, Level = EventLevel.Informational, Message = "{0}: Remove rule start. RuleName = {1}")] - public void RemoveRuleStart(string identifiers, string ruleName) + [Event(TransactionDeclaredEvent, Level = EventLevel.Informational, Message = "AmqpTransactionDeclared for LocalTransactionId: {0} AmqpTransactionId: {1}.")] + public void TransactionDeclared(string transactionId, string amqpTransactionId) { - if (IsEnabled()) - { - WriteEvent(71, identifiers, ruleName); - } + WriteEvent(TransactionDeclaredEvent, transactionId, amqpTransactionId); } - [Event(72, Level = EventLevel.Informational, Message = "{0}: Remove rule done.")] - public void RemoveRuleComplete(string identifier) + [NonEvent] + public void TransactionDischarged(string localTransactionId, ArraySegment amqpTransactionId, bool rollback) { if (IsEnabled()) { - WriteEvent(72, identifier); + TransactionDischarged(localTransactionId, amqpTransactionId.GetAsciiString(), rollback); } } - [Event(73, Level = EventLevel.Error, Message = "{0}: Remove rule Exception: {1}.")] - public void RemoveRuleException(string identifier, Exception exception) + [Event(TransactionDischargedEvent, Level = EventLevel.Informational, Message = "AmqpTransactionDischarged for LocalTransactionId: {0} AmqpTransactionId: {1} Rollback: {2}.")] + public void TransactionDischarged(string transactionId, string amqpTransactionId, bool rollback) + { + WriteEvent(TransactionDischargedEvent, transactionId, amqpTransactionId, rollback); + } + + [NonEvent] + public void TransactionDischargeException(string transactionId, ArraySegment amqpTransactionId, Exception exception) { if (IsEnabled()) { - WriteEvent(73, identifier, exception.ToString()); + TransactionDischargeException(transactionId, amqpTransactionId.GetAsciiString(), exception.ToString()); } } - [Event(74, Level = EventLevel.Informational, Message = "{0}: Get rule start.")] - public void GetRuleStart(string identifiers) + [Event(TransactionDischargedExceptionEvent, Level = EventLevel.Error, Message = "AmqpTransactionDischargeException for TransactionId: {0} AmqpTransactionId: {1} Exception: {2}.")] + public void TransactionDischargeException(string transactionId, string amqpTransactionId, string exception) + { + WriteEvent(TransactionDischargedExceptionEvent, transactionId, amqpTransactionId, exception); + } + + [Event(CreateControllerExceptionEvent, Level = EventLevel.Error, Message = "AmqpCreateControllerException for ConnectionManager: {0} Exception: {1}.")] + public void CreateControllerException(string connectionManager, string exception) { if (IsEnabled()) { - WriteEvent(74, identifiers); + WriteEvent(CreateControllerExceptionEvent, connectionManager, exception); } } + #endregion - [Event(75, Level = EventLevel.Informational, Message = "{0}: Get rule done.")] - public void GetRuleComplete(string identifier) + #region misc + [NonEvent] + public void ScheduleTaskFailed(Func task, Exception exception) { if (IsEnabled()) { - WriteEvent(75, identifier); + ScheduleTaskFailed(task.Target.GetType().FullName, task.GetMethodInfo().Name, exception.ToString()); } } - [Event(76, Level = EventLevel.Error, Message = "{0}: Get rule Exception: {1}.")] - public void GetRuleException(string identifier, Exception exception) + [Event(ScheduleTaskFailedEvent, Level = EventLevel.Error, Message = "Exception during Schedule Task. FunctionTargetName: {0}, MethodInfoName: {1}, Exception:{2}")] + public void ScheduleTaskFailed(string funcTargetName, string methodInfoName, string exception) + { + WriteEvent(ScheduleTaskFailedEvent, funcTargetName, methodInfoName, exception); + } + + [Event(ManagementSerializedExceptionEvent, Level = EventLevel.Warning, Message = "[De]Serialization failed for object:{0}; Details:{1}")] + public void ManagementSerializationException(string objectName, string details = "") { if (IsEnabled()) { - WriteEvent(76, identifier, exception.ToString()); + WriteEvent(ManagementSerializedExceptionEvent, objectName, details); } } + #endregion } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/CorrelationFilterExtensions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/CorrelationFilterExtensions.cs index f77e13d37a7e..43582af8234e 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/CorrelationFilterExtensions.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/CorrelationFilterExtensions.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using System.Xml.Linq; +using Azure.Messaging.ServiceBus.Diagnostics; using Azure.Messaging.ServiceBus.Management; namespace Azure.Messaging.ServiceBus.Filters @@ -48,7 +49,7 @@ public static Filter ParseFromXElement(XElement xElement) } break; default: - MessagingEventSource.Log.ManagementSerializationException( + ServiceBusEventSource.Log.ManagementSerializationException( $"{nameof(CorrelationFilterExtensions)}_{nameof(ParseFromXElement)}", element.ToString()); break; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/FilterExtensions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/FilterExtensions.cs index a861e0a6724e..3ec31ee8874a 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/FilterExtensions.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/FilterExtensions.cs @@ -3,6 +3,7 @@ using System; using System.Xml.Linq; +using Azure.Messaging.ServiceBus.Diagnostics; using Azure.Messaging.ServiceBus.Management; namespace Azure.Messaging.ServiceBus.Filters @@ -28,7 +29,7 @@ public static Filter ParseFromXElement(XElement xElement) case "FalseFilter": return new FalseFilter(); default: - MessagingEventSource.Log.ManagementSerializationException( + ServiceBusEventSource.Log.ManagementSerializationException( $"{nameof(FilterExtensions)}_{nameof(ParseFromXElement)}", xElement.ToString()); return null; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/RuleActionExtensions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/RuleActionExtensions.cs index 0c5047b03446..0442245924f1 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/RuleActionExtensions.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/RuleActionExtensions.cs @@ -3,6 +3,7 @@ using System; using System.Xml.Linq; +using Azure.Messaging.ServiceBus.Diagnostics; using Azure.Messaging.ServiceBus.Management; namespace Azure.Messaging.ServiceBus.Filters @@ -26,7 +27,7 @@ internal static RuleAction ParseFromXElement(XElement xElement) return null; default: - MessagingEventSource.Log.ManagementSerializationException( + ServiceBusEventSource.Log.ManagementSerializationException( $"{nameof(RuleActionExtensions)}_{nameof(ParseFromXElement)}", xElement.ToString()); return null; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/XmlObjectConvertor.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/XmlObjectConvertor.cs index fa9cf6a909f9..8771daa6d78b 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/XmlObjectConvertor.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Filters/XmlObjectConvertor.cs @@ -4,6 +4,7 @@ using System; using System.Xml; using System.Xml.Linq; +using Azure.Messaging.ServiceBus.Diagnostics; using Azure.Messaging.ServiceBus.Management; namespace Azure.Messaging.ServiceBus.Filters @@ -46,7 +47,7 @@ internal static object ParseValueObject(XElement element) case "duration": return XmlConvert.ToTimeSpan(element.Value); default: - MessagingEventSource.Log.ManagementSerializationException( + ServiceBusEventSource.Log.ManagementSerializationException( $"{nameof(XmlObjectConvertor)}_{nameof(ParseValueObject)}", element.ToString()); return element.Value; @@ -88,7 +89,7 @@ internal static XElement SerializeObject(object value) else { var unknownType = value.GetType().Name; - MessagingEventSource.Log.ManagementSerializationException( + ServiceBusEventSource.Log.ManagementSerializationException( $"{nameof(XmlObjectConvertor)}_{nameof(SerializeObject)}", unknownType); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/MessagingEventSource.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/MessagingEventSource.cs deleted file mode 100644 index 4af6bba96532..000000000000 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/MessagingEventSource.cs +++ /dev/null @@ -1,1393 +0,0 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. - -using System; -using System.Collections.Generic; -using System.Diagnostics.Tracing; -using System.Reflection; -using System.Text; -using System.Threading.Tasks; -using Azure.Messaging.ServiceBus.Primitives; -using Microsoft.Azure.Amqp; - -namespace Azure.Messaging.ServiceBus -{ - [EventSource(Name = "Microsoft-Azure-ServiceBus")] - internal sealed class MessagingEventSource : EventSource - { - public static MessagingEventSource Log { get; } = new MessagingEventSource(); - - [Event(1, Level = EventLevel.Informational, Message = "Creating QueueClient (Namespace '{0}'; Queue '{1}'; ReceiveMode '{2}').")] - public void QueueClientCreateStart(string namespaceName, string queueName, string receiveMode) - { - if (this.IsEnabled()) - { - this.WriteEvent(1, namespaceName ?? string.Empty, queueName, receiveMode); - } - } - - [Event(2, Level = EventLevel.Informational, Message = "QueueClient (Namespace '{0}'; Queue '{1}'; ClientId: '{2}' created).")] - public void QueueClientCreateStop(string namespaceName, string queueName, string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(2, namespaceName, queueName, clientId); - } - } - - [Event(3, Level = EventLevel.Informational, Message = "Creating TopicClient (Namespace '{0}'; Topic '{1}').")] - public void TopicClientCreateStart(string namespaceName, string topicName) - { - if (this.IsEnabled()) - { - this.WriteEvent(3, namespaceName ?? string.Empty, topicName); - } - } - - [Event(4, Level = EventLevel.Informational, Message = "TopicClient (Namespace '{0}'; Topic '{1}'; ClientId: '{2}' created).")] - public void TopicClientCreateStop(string namespaceName, string topicName, string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(4, namespaceName, topicName, clientId); - } - } - - [Event(5, Level = EventLevel.Informational, Message = "Creating SubscriptionClient (Namespace '{0}'; Topic '{1}'; Subscription '{2}'; ReceiveMode '{3}').")] - public void SubscriptionClientCreateStart(string namespaceName, string topicName, string subscriptionName, string receiveMode) - { - if (this.IsEnabled()) - { - this.WriteEvent(5, namespaceName, topicName ?? string.Empty, subscriptionName, receiveMode); - } - } - - [Event(6, Level = EventLevel.Informational, Message = "SubscriptionClient (Namespace '{0}'; Topic '{1}'; Subscription '{2}'; ClientId: '{3}' created).")] - public void SubscriptionClientCreateStop(string namespaceName, string topicName, string subscriptionName, string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(6, namespaceName, topicName, subscriptionName, clientId); - } - } - - [Event(7, Level = EventLevel.Informational, Message = "{0}: SendAsync start. MessageCount = {1}")] - public void MessageSendStart(string clientId, int messageCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(7, clientId, messageCount); - } - } - - [Event(8, Level = EventLevel.Informational, Message = "{0}: SendAsync done.")] - public void MessageSendStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(8, clientId); - } - } - - [NonEvent] - public void MessageSendException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageSendException(clientId, exception.ToString()); - } - } - - [Event(9, Level = EventLevel.Error, Message = "{0}: SendAsync Exception: {1}.")] - private void MessageSendException(string clientId, string exception) - { - this.WriteEvent(9, clientId, exception); - } - - [Event(10, Level = EventLevel.Informational, Message = "{0}: ReceiveAsync start. MessageCount = {1}")] - public void MessageReceiveStart(string clientId, int messageCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(10, clientId, messageCount); - } - } - - [Event(11, Level = EventLevel.Informational, Message = "{0}: ReceiveAsync done. Received '{1}' messages")] - public void MessageReceiveStop(string clientId, int messageCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(11, clientId, messageCount); - } - } - - [NonEvent] - public void MessageReceiveException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageReceiveException(clientId, exception.ToString()); - } - } - - [Event(12, Level = EventLevel.Error, Message = "{0}: ReceiveAsync Exception: {1}.")] - private void MessageReceiveException(string clientId, string exception) - { - this.WriteEvent(12, clientId, exception); - } - - [NonEvent] - public void MessageCompleteStart(string clientId, int messageCount, IEnumerable lockTokens) - { - if (this.IsEnabled()) - { - var formattedLockTokens = StringUtility.GetFormattedLockTokens(lockTokens); - this.MessageCompleteStart(clientId, messageCount, formattedLockTokens); - } - } - - [Event(13, Level = EventLevel.Informational, Message = "{0}: CompleteAsync start. MessageCount = {1}, LockTokens = {2}")] - private void MessageCompleteStart(string clientId, int messageCount, string lockTokens) - { - this.WriteEvent(13, clientId, messageCount, lockTokens); - } - - [Event(14, Level = EventLevel.Informational, Message = "{0}: CompleteAsync done.")] - public void MessageCompleteStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(14, clientId); - } - } - - [NonEvent] - public void MessageCompleteException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageCompleteException(clientId, exception.ToString()); - } - } - - [Event(15, Level = EventLevel.Error, Message = "{0}: CompleteAsync Exception: {1}.")] - public void MessageCompleteException(string clientId, string exception) - { - this.WriteEvent(15, clientId, exception); - } - - [Event(16, Level = EventLevel.Informational, Message = "{0}: AbandonAsync start. MessageCount = {1}, LockToken = {2}")] - public void MessageAbandonStart(string clientId, int messageCount, string lockToken) - { - if (this.IsEnabled()) - { - this.WriteEvent(16, clientId, messageCount, lockToken); - } - } - - [Event(17, Level = EventLevel.Informational, Message = "{0}: AbandonAsync done.")] - public void MessageAbandonStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(17, clientId); - } - } - - [NonEvent] - public void MessageAbandonException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageAbandonException(clientId, exception.ToString()); - } - } - - [Event(18, Level = EventLevel.Error, Message = "{0}: AbandonAsync Exception: {1}.")] - public void MessageAbandonException(string clientId, string exception) - { - this.WriteEvent(18, clientId, exception); - } - - [Event(19, Level = EventLevel.Informational, Message = "{0}: DeferAsync start. MessageCount = {1}, LockToken = {2}")] - public void MessageDeferStart(string clientId, int messageCount, string lockToken) - { - if (this.IsEnabled()) - { - this.WriteEvent(19, clientId, messageCount, lockToken); - } - } - - [Event(20, Level = EventLevel.Informational, Message = "{0}: DeferAsync done.")] - public void MessageDeferStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(20, clientId); - } - } - - [NonEvent] - public void MessageDeferException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageDeferException(clientId, exception.ToString()); - } - } - - [Event(21, Level = EventLevel.Error, Message = "{0}: DeferAsync Exception: {1}.")] - public void MessageDeferException(string clientId, string exception) - { - this.WriteEvent(21, clientId, exception); - } - - [Event(22, Level = EventLevel.Informational, Message = "{0}: DeadLetterAsync start. MessageCount = {1}, LockToken = {2}")] - public void MessageDeadLetterStart(string clientId, int messageCount, string lockToken) - { - if (this.IsEnabled()) - { - this.WriteEvent(22, clientId, messageCount, lockToken); - } - } - - [Event(23, Level = EventLevel.Informational, Message = "{0}: DeadLetterAsync done.")] - public void MessageDeadLetterStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(23, clientId); - } - } - - [NonEvent] - public void MessageDeadLetterException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageDeadLetterException(clientId, exception.ToString()); - } - } - - [Event(24, Level = EventLevel.Error, Message = "{0}: DeadLetterAsync Exception: {1}.")] - public void MessageDeadLetterException(string clientId, string exception) - { - this.WriteEvent(24, clientId, exception); - } - - [Event(25, Level = EventLevel.Informational, Message = "{0}: RenewLockAsync start. MessageCount = {1}, LockToken = {2}")] - public void MessageRenewLockStart(string clientId, int messageCount, string lockToken) - { - if (this.IsEnabled()) - { - this.WriteEvent(25, clientId, messageCount, lockToken); - } - } - - [Event(26, Level = EventLevel.Informational, Message = "{0}: RenewLockAsync done.")] - public void MessageRenewLockStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(26, clientId); - } - } - - [NonEvent] - public void MessageRenewLockException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageRenewLockException(clientId, exception.ToString()); - } - } - - [Event(27, Level = EventLevel.Error, Message = "{0}: RenewLockAsync Exception: {1}.")] - public void MessageRenewLockException(string clientId, string exception) - { - this.WriteEvent(27, clientId, exception); - } - - [NonEvent] - public void MessageReceiveDeferredMessageStart(string clientId, int messageCount, IEnumerable sequenceNumbers) - { - if (this.IsEnabled()) - { - var formattedSequenceNumbers = StringUtility.GetFormattedSequenceNumbers(sequenceNumbers); - this.MessageReceiveDeferredMessageStart(clientId, messageCount, formattedSequenceNumbers); - } - } - - [Event(28, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync start. MessageCount = {1}, LockTokens = {2}")] - public void MessageReceiveDeferredMessageStart(string clientId, int messageCount, string sequenceNumbers) - { - this.WriteEvent(28, clientId, messageCount, sequenceNumbers); - } - - [Event(29, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync done. Received '{1}' messages")] - public void MessageReceiveDeferredMessageStop(string clientId, int messageCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(29, clientId, messageCount); - } - } - - [NonEvent] - public void MessageReceiveDeferredMessageException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageReceiveDeferredMessageException(clientId, exception.ToString()); - } - } - - [Event(30, Level = EventLevel.Error, Message = "{0}: ReceiveDeferredMessageAsync Exception: {1}.")] - public void MessageReceiveDeferredMessageException(string clientId, string exception) - { - this.WriteEvent(30, clientId, exception); - } - - // Unused - 31;32;33 - - [NonEvent] - public void AmqpSendLinkCreateStart(string clientId, MessagingEntityType? entityType, string entityPath) - { - if (this.IsEnabled()) - { - this.AmqpSendLinkCreateStart(clientId, entityType?.ToString() ?? string.Empty, entityPath); - } - } - - [Event(34, Level = EventLevel.Informational, Message = "{0}: AmqpSendLinkCreate started. EntityType: {1}, EntityPath: {2}")] - public void AmqpSendLinkCreateStart(string clientId, string entityType, string entityPath) - { - this.WriteEvent(34, clientId, entityType, entityPath); - } - - [Event(35, Level = EventLevel.Informational, Message = "{0}: AmqpSendLinkCreate done.")] - public void AmqpSendLinkCreateStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(35, clientId); - } - } - - [NonEvent] - public void AmqpReceiveLinkCreateStart(string clientId, bool isRequestResponseLink, MessagingEntityType? entityType, string entityPath) - { - if (this.IsEnabled()) - { - this.AmqpReceiveLinkCreateStart(clientId, isRequestResponseLink.ToString(), entityType?.ToString() ?? string.Empty, entityPath); - } - } - - [Event(36, Level = EventLevel.Informational, Message = "{0}: AmqpReceiveLinkCreate started. IsRequestResponseLink: {1}, EntityType: {1}, EntityPath: {2}")] - public void AmqpReceiveLinkCreateStart(string clientId, string isRequestResponseLink, string entityType, string entityPath) - { - this.WriteEvent(36, clientId, isRequestResponseLink, entityType, entityPath); - } - - [Event(37, Level = EventLevel.Informational, Message = "{0}: AmqpReceiveLinkCreate done.")] - public void AmqpReceiveLinkCreateStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(37, clientId); - } - } - - [Event(38, Level = EventLevel.Verbose, Message = "AmqpGetOrCreateConnection started.")] - public void AmqpGetOrCreateConnectionStart() - { - if (this.IsEnabled()) - { - this.WriteEvent(38); - } - } - - [Event(39, Level = EventLevel.Verbose, Message = "AmqpGetOrCreateConnection done. EntityPath: {0}, ConnectionInfo: {1}, ConnectionState: {2}")] - public void AmqpGetOrCreateConnectionStop(string entityPath, string connectionInfo, string connectionState) - { - if (this.IsEnabled()) - { - this.WriteEvent(39, entityPath, connectionInfo, connectionState); - } - } - - [NonEvent] - public void AmqpSendAuthenticationTokenStart(Uri address, string audience, string resource, string[] claims) - { - if (this.IsEnabled()) - { - this.AmqpSendAuthenticationTokenStart(address.ToString(), audience, resource, claims.ToString()); - } - } - - [Event(40, Level = EventLevel.Verbose, Message = "AmqpSendAuthenticanToken started. Address: {0}, Audience: {1}, Resource: {2}, Claims: {3}")] - public void AmqpSendAuthenticationTokenStart(string address, string audience, string resource, string claims) - { - this.WriteEvent(40, address, audience, resource, claims); - } - - [Event(41, Level = EventLevel.Verbose, Message = "AmqpSendAuthenticanToken done.")] - public void AmqpSendAuthenticationTokenStop() - { - if (this.IsEnabled()) - { - this.WriteEvent(41); - } - } - - [Event(42, Level = EventLevel.Informational, Message = "{0}: MessagePeekAsync start. SequenceNumber = {1}, MessageCount = {2}")] - public void MessagePeekStart(string clientId, long sequenceNumber, int messageCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(42, clientId, sequenceNumber, messageCount); - } - } - - [Event(43, Level = EventLevel.Informational, Message = "{0}: MessagePeekAsync done. Peeked '{1}' messages")] - public void MessagePeekStop(string clientId, int messageCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(43, clientId, messageCount); - } - } - - [NonEvent] - public void MessagePeekException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessagePeekException(clientId, exception.ToString()); - } - } - - [Event(44, Level = EventLevel.Error, Message = "{0}: MessagePeekAsync Exception: {1}.")] - private void MessagePeekException(string clientId, string exception) - { - this.WriteEvent(44, clientId, exception); - } - - [Event(45, Level = EventLevel.Informational, Message = "Creating MessageSender (Namespace '{0}'; Entity '{1}').")] - public void MessageSenderCreateStart(string namespaceName, string entityName) - { - if (this.IsEnabled()) - { - this.WriteEvent(45, namespaceName, entityName); - } - } - - [Event(46, Level = EventLevel.Informational, Message = "MessageSender (Namespace '{0}'; Entity '{1}'; ClientId '{2}' created).")] - public void MessageSenderCreateStop(string namespaceName, string entityName, string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(46, namespaceName, entityName, clientId); - } - } - - [Event(47, Level = EventLevel.Informational, Message = "Creating MessageReceiver (Namespace '{0}'; Entity '{1}'; ReceiveMode '{2}').")] - public void MessageReceiverCreateStart(string namespaceName, string entityName, string receiveMode) - { - if (this.IsEnabled()) - { - this.WriteEvent(47, namespaceName, entityName, receiveMode); - } - } - - [Event(48, Level = EventLevel.Informational, Message = "MessageReceiver (Namespace '{0}'; Entity '{1}'; ClientId '{2}' created).")] - public void MessageReceiverCreateStop(string namespaceName, string entityName, string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(48, namespaceName, entityName, clientId); - } - } - - [NonEvent] - public void ScheduleMessageStart(string clientId, DateTimeOffset scheduleEnqueueTimeUtc) - { - if (this.IsEnabled()) - { - this.ScheduleMessageStart(clientId, scheduleEnqueueTimeUtc.ToString()); - } - } - - [Event(49, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync start. ScheduleTimeUtc = {1}")] - private void ScheduleMessageStart(string clientId, string scheduleEnqueueTimeUtc) - { - if (this.IsEnabled()) - { - this.WriteEvent(49, clientId, scheduleEnqueueTimeUtc); - } - } - - [Event(50, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync done.")] - public void ScheduleMessageStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(50, clientId); - } - } - - [NonEvent] - public void ScheduleMessageException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.ScheduleMessageException(clientId, exception.ToString()); - } - } - - [Event(51, Level = EventLevel.Error, Message = "{0}: ScheduleMessageAsync Exception: {1}.")] - private void ScheduleMessageException(string clientId, string exception) - { - this.WriteEvent(51, clientId, exception); - } - - [Event(52, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync start. SequenceNumber = {1}")] - public void CancelScheduledMessageStart(string clientId, long sequenceNumber) - { - if (this.IsEnabled()) - { - this.WriteEvent(52, clientId, sequenceNumber); - } - } - - [Event(53, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync done.")] - public void CancelScheduledMessageStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(53, clientId); - } - } - - [NonEvent] - public void CancelScheduledMessageException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.CancelScheduledMessageException(clientId, exception.ToString()); - } - } - - [Event(54, Level = EventLevel.Error, Message = "{0}: CancelScheduledMessageAsync Exception: {1}.")] - public void CancelScheduledMessageException(string clientId, string exception) - { - this.WriteEvent(54, clientId, exception); - } - - [Event(55, Level = EventLevel.Informational, Message = "{0}: AddRuleAsync start. RuleName = {1}")] - public void AddRuleStart(string clientId, string ruleName) - { - if (this.IsEnabled()) - { - this.WriteEvent(55, clientId, ruleName); - } - } - - [Event(56, Level = EventLevel.Informational, Message = "{0}: AddRuleAsync done.")] - public void AddRuleStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(56, clientId); - } - } - - [NonEvent] - public void AddRuleException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.AddRuleException(clientId, exception.ToString()); - } - } - - [Event(57, Level = EventLevel.Error, Message = "{0}: AddRuleAsync Exception: {1}.")] - public void AddRuleException(string clientId, string exception) - { - this.WriteEvent(57, clientId, exception); - } - - [Event(58, Level = EventLevel.Informational, Message = "{0}: RemoveRuleAsync start. RuleName = {1}")] - public void RemoveRuleStart(string clientId, string ruleName) - { - if (this.IsEnabled()) - { - this.WriteEvent(58, clientId, ruleName); - } - } - - [Event(59, Level = EventLevel.Informational, Message = "{0}: RemoveRuleAsync done.")] - public void RemoveRuleStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(59, clientId); - } - } - - [NonEvent] - public void RemoveRuleException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.RemoveRuleException(clientId, exception.ToString()); - } - } - - [Event(60, Level = EventLevel.Error, Message = "{0}: RemoveRuleAsync Exception: {1}.")] - public void RemoveRuleException(string clientId, string exception) - { - this.WriteEvent(60, clientId, exception); - } - - //[NonEvent] - //public void RegisterOnMessageHandlerStart(string clientId, MessageHandlerOptions registerHandlerOptions) - //{ - // if (this.IsEnabled()) - // { - // this.RegisterOnMessageHandlerStart(clientId, registerHandlerOptions.AutoComplete, registerHandlerOptions.AutoRenewLock, registerHandlerOptions.MaxConcurrentCalls, (long)registerHandlerOptions.MaxAutoRenewDuration.TotalSeconds); - // } - //} - - [Event(61, Level = EventLevel.Informational, Message = "{0}: Register OnMessageHandler start: OnMessage Options: AutoComplete: {1}, AutoRenewLock: {2}, MaxConcurrentCalls: {3}, AutoRenewTimeout: {4}")] - public void RegisterOnMessageHandlerStart(string clientId, bool autoComplete, bool autorenewLock, int maxConcurrentCalls, long autorenewTimeoutInSeconds) - { - this.WriteEvent(61, clientId, autoComplete, autorenewLock, maxConcurrentCalls, autorenewTimeoutInSeconds); - } - - [Event(62, Level = EventLevel.Informational, Message = "{0}: Register OnMessageHandler done.")] - public void RegisterOnMessageHandlerStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(62, clientId); - } - } - - [NonEvent] - public void RegisterOnMessageHandlerException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.RegisterOnMessageHandlerException(clientId, exception.ToString()); - } - } - - [Event(63, Level = EventLevel.Error, Message = "{0}: Register OnMessageHandler Exception: {1}")] - private void RegisterOnMessageHandlerException(string clientId, string exception) - { - this.WriteEvent(63, clientId, exception); - } - - [NonEvent] - public void MessageReceiverPumpTaskStart(string clientId, ServiceBusReceivedMessage message, int currentSemaphoreCount) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpTaskStart(clientId, message?.SequenceNumber ?? -1, currentSemaphoreCount); - } - } - - [Event(66, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump PumpTask Started: Message: SequenceNumber: {1}, Available Semaphore Count: {2}")] - private void MessageReceiverPumpTaskStart(string clientId, long sequenceNumber, int currentSemaphoreCount) - { - this.WriteEvent(66, clientId, sequenceNumber, currentSemaphoreCount); - } - - [Event(67, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump PumpTask done: Available Semaphore Count: {1}")] - public void MessageReceiverPumpTaskStop(string clientId, int currentSemaphoreCount) - { - if (this.IsEnabled()) - { - this.WriteEvent(67, clientId, currentSemaphoreCount); - } - } - - [NonEvent] - public void MessageReceivePumpTaskException(string clientId, string sessionId, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageReceivePumpTaskException(clientId, sessionId, exception.ToString()); - } - } - - [Event(68, Level = EventLevel.Error, Message = "{0}: MessageReceiverPump PumpTask Exception: SessionId: {1}, Exception: {2}")] - public void MessageReceivePumpTaskException(string clientId, string sessionId, string exception) - { - this.WriteEvent(68, clientId, sessionId, exception); - } - - [NonEvent] - public void MessageReceiverPumpDispatchTaskStart(string clientId, ServiceBusReceivedMessage message) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpDispatchTaskStart(clientId, message?.SequenceNumber ?? -1); - } - } - - [Event(69, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump DispatchTask start: Message: SequenceNumber: {1}")] - public void MessageReceiverPumpDispatchTaskStart(string clientId, long sequenceNumber) - { - this.WriteEvent(69, clientId, sequenceNumber); - } - - [NonEvent] - public void MessageReceiverPumpDispatchTaskStop(string clientId, ServiceBusReceivedMessage message, int currentSemaphoreCount) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpDispatchTaskStop(clientId, message?.SequenceNumber ?? -1, currentSemaphoreCount); - } - } - - [Event(70, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump DispatchTask done: Message: SequenceNumber: {1}, Current Semaphore Count: {2}")] - private void MessageReceiverPumpDispatchTaskStop(string clientId, long sequenceNumber, int currentSemaphoreCount) - { - this.WriteEvent(70, clientId, sequenceNumber, currentSemaphoreCount); - } - - [NonEvent] - public void MessageReceiverPumpUserCallbackStart(string clientId, ServiceBusReceivedMessage message) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpUserCallbackStart(clientId, message?.SequenceNumber ?? -1); - } - } - - [Event(71, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump UserCallback start: Message: SequenceNumber: {1}")] - public void MessageReceiverPumpUserCallbackStart(string clientId, long sequenceNumber) - { - this.WriteEvent(71, clientId, sequenceNumber); - } - - [NonEvent] - public void MessageReceiverPumpUserCallbackStop(string clientId, ServiceBusReceivedMessage message) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpUserCallbackStop(clientId, message?.SequenceNumber ?? -1); - } - } - - [Event(72, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump UserCallback done: Message: SequenceNumber: {1}")] - public void MessageReceiverPumpUserCallbackStop(string clientId, long sequenceNumber) - { - this.WriteEvent(72, clientId, sequenceNumber); - } - - [NonEvent] - public void MessageReceiverPumpUserCallbackException(string clientId, ServiceBusReceivedMessage message, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpUserCallbackException(clientId, message?.SequenceNumber ?? -1, exception.ToString()); - } - } - - [Event(73, Level = EventLevel.Error, Message = "{0}: MessageReceiverPump UserCallback Exception: Message: SequenceNumber: {1}, Exception: {2}")] - public void MessageReceiverPumpUserCallbackException(string clientId, long sequenceNumber, string exception) - { - this.WriteEvent(73, clientId, sequenceNumber, exception); - } - - [NonEvent] - public void MessageReceiverPumpRenewMessageStart(string clientId, ServiceBusReceivedMessage message, TimeSpan renewAfterTimeSpan) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpRenewMessageStart(clientId, message?.SequenceNumber ?? -1, (long)renewAfterTimeSpan.TotalSeconds); - } - } - - [Event(74, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump RenewMessage start: Message: SequenceNumber: {1}, RenewAfterTimeInSeconds: {2}")] - public void MessageReceiverPumpRenewMessageStart(string clientId, long sequenceNumber, long renewAfterTimeSpanInSeconds) - { - this.WriteEvent(74, clientId, sequenceNumber, renewAfterTimeSpanInSeconds); - } - - [NonEvent] - public void MessageReceiverPumpRenewMessageStop(string clientId, ServiceBusReceivedMessage message) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpRenewMessageStop(clientId, message?.SequenceNumber ?? -1); - } - } - - [Event(75, Level = EventLevel.Informational, Message = "{0}: MessageReceiverPump RenewMessage done: Message: SequenceNumber: {1}")] - public void MessageReceiverPumpRenewMessageStop(string clientId, long sequenceNumber) - { - this.WriteEvent(75, clientId, sequenceNumber); - } - - [NonEvent] - public void MessageReceiverPumpRenewMessageException(string clientId, ServiceBusReceivedMessage message, Exception exception) - { - if (this.IsEnabled()) - { - this.MessageReceiverPumpRenewMessageException(clientId, message?.SequenceNumber ?? -1, exception.ToString()); - } - } - - [Event(76, Level = EventLevel.Error, Message = "{0}: MessageReceiverPump RenewMessage Exception: Message: SequenceNumber: {1}, Exception: {2}")] - public void MessageReceiverPumpRenewMessageException(string clientId, long sequenceNumber, string exception) - { - this.WriteEvent(76, clientId, sequenceNumber, exception); - } - - [NonEvent] - public void RunOperationExceptionEncountered(Exception exception) - { - if (this.IsEnabled()) - { - this.RunOperationExceptionEncountered(exception.ToString()); - } - } - - [Event(77, Level = EventLevel.Warning, Message = "RunOperation encountered an exception and will retry. Exception: {0}")] - public void RunOperationExceptionEncountered(string exception) - { - this.WriteEvent(77, exception); - } - - //[NonEvent] - //public void RegisterOnSessionHandlerStart(string clientId, SessionHandlerOptions sessionHandlerOptions) - //{ - // if (this.IsEnabled()) - // { - // this.RegisterOnSessionHandlerStart(clientId, sessionHandlerOptions.AutoComplete, sessionHandlerOptions.MaxConcurrentSessions, (long)sessionHandlerOptions.MessageWaitTimeout.TotalSeconds, (long)sessionHandlerOptions.MaxAutoRenewDuration.TotalSeconds); - // } - //} - - [Event(78, Level = EventLevel.Informational, Message = "{0}: Register OnSessionHandler start: RegisterSessionHandler Options: AutoComplete: {1}, MaxConcurrentSessions: {2}, MessageWaitTimeout: {3}, AutoRenewTimeout: {4}")] - public void RegisterOnSessionHandlerStart(string clientId, bool autoComplete, int maxConcurrentSessions, long messageWaitTimeoutInSeconds, long autorenewTimeoutInSeconds) - { - this.WriteEvent(78, clientId, autoComplete, maxConcurrentSessions, messageWaitTimeoutInSeconds, autorenewTimeoutInSeconds); - } - - [Event(79, Level = EventLevel.Informational, Message = "{0}: Register OnSessionHandler done.")] - public void RegisterOnSessionHandlerStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(79, clientId); - } - } - - [NonEvent] - public void RegisterOnSessionHandlerException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.RegisterOnSessionHandlerException(clientId, exception.ToString()); - } - } - - [Event(80, Level = EventLevel.Error, Message = "{0}: Register OnSessionHandler Exception: {1}")] - public void RegisterOnSessionHandlerException(string clientId, string exception) - { - this.WriteEvent(80, clientId, exception); - } - - [NonEvent] - public void SessionReceivePumpSessionReceiveException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.SessionReceivePumpSessionReceiveException(clientId, exception.ToString()); - } - } - - [Event(81, Level = EventLevel.Error, Message = "{0}: Exception while Receving a session: SessionId: {1}")] - public void SessionReceivePumpSessionReceiveException(string clientId, string exception) - { - this.WriteEvent(81, clientId, exception); - } - - [Event(82, Level = EventLevel.Informational, Message = "{0}: Session has no more messages: SessionId: {1}")] - public void SessionReceivePumpSessionEmpty(string clientId, string sessionId) - { - if (this.IsEnabled()) - { - this.WriteEvent(82, clientId, sessionId); - } - } - - [Event(83, Level = EventLevel.Informational, Message = "{0}: Session closed: SessionId: {1}")] - public void SessionReceivePumpSessionClosed(string clientId, string sessionId) - { - if (this.IsEnabled()) - { - this.WriteEvent(83, clientId, sessionId); - } - } - - [NonEvent] - public void SessionReceivePumpSessionCloseException(string clientId, string sessionId, Exception exception) - { - if (this.IsEnabled()) - { - this.SessionReceivePumpSessionCloseException(clientId, sessionId, exception.ToString()); - } - } - - [Event(84, Level = EventLevel.Error, Message = "{0}: Exception while closing session: SessionId: {1}, Exception: {2}")] - private void SessionReceivePumpSessionCloseException(string clientId, string sessionId, string exception) - { - this.WriteEvent(84, clientId, sessionId, exception); - } - - [NonEvent] - public void SessionReceivePumpSessionRenewLockStart(string clientId, string sessionId, TimeSpan renewAfterTimeSpan) - { - if (this.IsEnabled()) - { - this.SessionReceivePumpSessionRenewLockStart(clientId, sessionId, (long)renewAfterTimeSpan.TotalSeconds); - } - } - - [Event(85, Level = EventLevel.Informational, Message = "{0}: SessionRenewLock start. SessionId: {1}, RenewAfterTimeInSeconds: {2}")] - public void SessionReceivePumpSessionRenewLockStart(string clientId, string sessionId, long totalSeconds) - { - this.WriteEvent(85, clientId, sessionId, totalSeconds); - } - - [Event(86, Level = EventLevel.Informational, Message = "{0}: RenewSession done: SessionId: {1}")] - public void SessionReceivePumpSessionRenewLockStop(string clientId, string sessionId) - { - if (this.IsEnabled()) - { - this.WriteEvent(86, clientId, sessionId); - } - } - - [NonEvent] - public void SessionReceivePumpSessionRenewLockException(string clientId, string sessionId, Exception exception) - { - if (this.IsEnabled()) - { - this.SessionReceivePumpSessionRenewLockException(clientId, sessionId, exception.ToString()); - } - } - - [Event(87, Level = EventLevel.Error, Message = "{0}: Exception while renewing session lock: SessionId: {1}, Exception: {2}")] - public void SessionReceivePumpSessionRenewLockException(string clientId, string sessionId, string exception) - { - this.WriteEvent(87, clientId, sessionId, exception); - } - - //[NonEvent] - //public void AmqpSessionClientAcceptMessageSessionStart(string clientId, string entityPath, ReceiveMode receiveMode, int prefetchCount, string sessionId) - //{ - // if (this.IsEnabled()) - // { - // this.AmqpSessionClientAcceptMessageSessionStart(clientId, entityPath, receiveMode.ToString(), prefetchCount, sessionId ?? string.Empty); - // } - //} - - [Event(88, Level = EventLevel.Informational, Message = "{0}: AcceptMessageSession start: EntityPath: {1}, ReceiveMode: {2}, PrefetchCount: {3}, SessionId: {4}")] - public void AmqpSessionClientAcceptMessageSessionStart(string clientId, string entityPath, string receiveMode, int prefetchCount, string sessionId) - { - this.WriteEvent(88, clientId, entityPath, receiveMode, prefetchCount, sessionId); - } - - [Event(89, Level = EventLevel.Informational, Message = "{0}: AcceptMessageSession done: EntityPath: {1}, SessionId: {2}")] - public void AmqpSessionClientAcceptMessageSessionStop(string clientId, string entityPath, string sessionId) - { - if (this.IsEnabled()) - { - this.WriteEvent(89, clientId, entityPath, sessionId); - } - } - - [NonEvent] - public void AmqpSessionClientAcceptMessageSessionException(string clientId, string entityPath, Exception exception) - { - if (this.IsEnabled()) - { - this.AmqpSessionClientAcceptMessageSessionException(clientId, entityPath, exception.ToString()); - } - } - - [Event(90, Level = EventLevel.Error, Message = "{0}: AcceptMessageSession Exception: EntityPath: {1}, Exception: {2}")] - public void AmqpSessionClientAcceptMessageSessionException(string clientId, string entityPath, string exception) - { - this.WriteEvent(90, clientId, entityPath, exception); - } - - //[NonEvent] - //public void AmqpLinkCreationException(string entityPath, AmqpSession session, AmqpConnection connection, Exception exception) - //{ - // if (this.IsEnabled()) - // { - // this.AmqpLinkCreationException(entityPath, session.ToString(), session.State.ToString(), session.GetInnerException()?.ToString() ?? string.Empty, connection.ToString(), connection.State.ToString(), exception.ToString()); - // } - //} - - [Event(91, Level = EventLevel.Error, Message = "AmqpLinkCreatorException Exception: EntityPath: {0}, SessionString: {1}, SessionState: {2}, TerminalException: {3}, ConnectionInfo: {4}, ConnectionState: {5}, Exception: {6}")] - public void AmqpLinkCreationException(string entityPath, string session, string sessionState, string terminalException, string connectionInfo, string connectionState, string exception) - { - this.WriteEvent(91, entityPath, session, sessionState, terminalException, connectionInfo, connectionState, exception); - } - - [NonEvent] - public void AmqpConnectionCreated(string hostName, AmqpConnection connection) - { - if (this.IsEnabled()) - { - this.AmqpConnectionCreated(hostName, connection.ToString(), connection.State.ToString()); - } - } - - [Event(92, Level = EventLevel.Verbose, Message = "AmqpConnectionCreated: HostName: {0}, ConnectionInfo: {1}, ConnectionState: {2}")] - public void AmqpConnectionCreated(string hostName, string connectionInfo, string connectionState) - { - this.WriteEvent(92, hostName, connectionInfo, connectionState); - } - - [NonEvent] - public void AmqpConnectionClosed(AmqpConnection connection) - { - if (this.IsEnabled()) - { - this.AmqpConnectionClosed(connection.RemoteEndpoint, connection.ToString(), connection.State.ToString()); - } - } - - [Event(93, Level = EventLevel.Verbose, Message = "AmqpConnectionClosed: HostName: {0}, ConnectionInfo: {1}, ConnectionState: {2}")] - public void AmqpConnectionClosed(string hostName, string connectionInfo, string connectionState) - { - this.WriteEvent(93, hostName, connectionInfo, connectionState); - } - - [NonEvent] - public void AmqpSessionCreationException(string entityPath, AmqpConnection connection, Exception exception) - { - if (this.IsEnabled()) - { - this.AmqpSessionCreationException(entityPath, connection.ToString(), connection.State.ToString(), exception.ToString()); - } - } - - [Event(94, Level = EventLevel.Error, Message = "AmqpSessionCreationException Exception: EntityPath: {0}, ConnectionInfo: {1}, ConnectionState: {2}, Exception: {3}")] - public void AmqpSessionCreationException(string entityPath, string connectionInfo, string connectionState, string exception) - { - this.WriteEvent(94, entityPath, connectionInfo, connectionState, exception); - } - - [Event(95, Level = EventLevel.Verbose, Message = "User plugin {0} called on message {1}")] - public void PluginCallStarted(string pluginName, string messageId) - { - if (this.IsEnabled()) - { - this.WriteEvent(95, pluginName, messageId); - } - } - - [Event(96, Level = EventLevel.Verbose, Message = "User plugin {0} completed on message {1}")] - public void PluginCallCompleted(string pluginName, string messageId) - { - if (this.IsEnabled()) - { - this.WriteEvent(96, pluginName, messageId); - } - } - - [NonEvent] - public void PluginCallFailed(string pluginName, string messageId, Exception exception) - { - if (this.IsEnabled()) - { - this.PluginCallFailed(pluginName, messageId, exception.ToString()); - } - } - - [Event(97, Level = EventLevel.Error, Message = "Exception during {0} plugin execution. MessageId: {1}, Exception {2}")] - public void PluginCallFailed(string pluginName, string messageId, string exception) - { - this.WriteEvent(97, pluginName, messageId, exception); - } - - [NonEvent] - public void ScheduleTaskFailed(Func task, Exception exception) - { - if (this.IsEnabled()) - { - this.ScheduleTaskFailed(task.Target.GetType().FullName, task.GetMethodInfo().Name, exception.ToString()); - } - } - - [Event(98, Level = EventLevel.Error, Message = "Exception during Schedule Task. FunctionTargetName: {0}, MethodInfoName: {1}, Exception:{2}")] - public void ScheduleTaskFailed(string funcTargetName, string methodInfoName, string exception) - { - WriteEvent(98, funcTargetName, methodInfoName, exception); - } - - [NonEvent] - public void ExceptionReceivedHandlerThrewException(Exception exception) - { - if (this.IsEnabled()) - { - this.ExceptionReceivedHandlerThrewException(exception.ToString()); - } - } - - [Event(99, Level = EventLevel.Error, Message = "ExceptionReceivedHandler threw exception. Exception:{0}")] - public void ExceptionReceivedHandlerThrewException(string exception) - { - WriteEvent(99, exception); - } - - [NonEvent] - public void LinkStateLost(string clientId, string receiveLinkName, AmqpObjectState receiveLinkState, bool isSessionReceiver, Exception exception) - { - if (this.IsEnabled()) - { - this.LinkStateLost(clientId, receiveLinkName, receiveLinkState.ToString(), isSessionReceiver, exception.ToString()); - } - } - - [Event(100, Level = EventLevel.Error, Message = "Link state lost. Throwing LockLostException for clientId: {0}, receiveLinkName: {1}, receiveLinkState: {2}, isSessionReceiver: {3}, exception: {4}.")] - public void LinkStateLost(string clientId, string receiveLinkName, string receiveLinkState, bool isSessionReceiver, string exception) - { - WriteEvent(100, clientId, receiveLinkName, receiveLinkState, isSessionReceiver, exception); - } - - [Event(101, Level = EventLevel.Informational, Message = "Updating client id. OldClientId: {0}, NewClientId: {1}")] - public void UpdateClientId(string oldClientId, string newClientId) - { - if (this.IsEnabled()) - { - WriteEvent(101, oldClientId, newClientId); - } - } - - [Event(102, Level = EventLevel.Informational, Message = "{0}: GetRulesException start.")] - public void GetRulesStart(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(102, clientId); - } - } - - [Event(103, Level = EventLevel.Informational, Message = "{0}: GetRulesException done.")] - public void GetRulesStop(string clientId) - { - if (this.IsEnabled()) - { - this.WriteEvent(103, clientId); - } - } - - [NonEvent] - public void GetRulesException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.GetRulesException(clientId, exception.ToString()); - } - } - - [Event(104, Level = EventLevel.Error, Message = "{0}: GetRulesException Exception: {1}.")] - public void GetRulesException(string clientId, string exception) - { - this.WriteEvent(104, clientId, exception); - } - - [NonEvent] - public void CreatingNewLink(string clientId, bool isSessionReceiver, string sessionId, bool isRequestResponseLink, Exception linkException) - { - if (this.IsEnabled()) - { - this.CreatingNewLink(clientId, isSessionReceiver, sessionId ?? string.Empty, isRequestResponseLink, linkException?.ToString() ?? string.Empty); - } - } - - [Event(105, Level = EventLevel.Informational, Message = "Creating/Recreating New Link. ClientId: {0}, IsSessionReceiver: {1}, SessionId: {2}, IsRequestResponseLink: {3}, LinkError: {4}.")] - public void CreatingNewLink(string clientId, bool isSessionReceiver, string sessionId, bool isRequestResponseLink, string linkError) - { - WriteEvent(105, clientId, isSessionReceiver, sessionId, isRequestResponseLink, linkError); - } - - [NonEvent] - public void SessionReceiverLinkClosed(string clientId, string sessionId, Exception linkException) - { - if (this.IsEnabled()) - { - this.SessionReceiverLinkClosed(clientId, sessionId ?? string.Empty, linkException?.ToString() ?? string.Empty); - } - } - - [Event(106, Level = EventLevel.Error, Message = "SessionReceiver Link Closed. ClientId: {0}, SessionId: {1}, linkException: {2}.")] - public void SessionReceiverLinkClosed(string clientId, string sessionId, string linkException) - { - WriteEvent(106, clientId, sessionId, linkException); - } - - [NonEvent] - public void AmqpSendAuthenticationTokenException(string clientId, Exception exception) - { - if (this.IsEnabled()) - { - this.AmqpSendAuthenticationTokenException(clientId, exception.ToString()); - } - } - - [Event(107, Level = EventLevel.Error, Message = "{0}: AmqpSendAuthenticationTokenException Exception: {1}.")] - public void AmqpSendAuthenticationTokenException(string clientId, string exception) - { - this.WriteEvent(107, clientId, exception); - } - - [NonEvent] - public void AmqpTransactionInitializeException(string transactionId, Exception exception) - { - if (this.IsEnabled()) - { - this.AmqpTransactionInitializeException(transactionId, exception.ToString()); - } - } - - [Event(108, Level = EventLevel.Error, Message = "AmqpTransactionInitializeException for TransactionId: {0} Exception: {1}.")] - public void AmqpTransactionInitializeException(string transactionId, string exception) - { - this.WriteEvent(108, transactionId, exception); - } - - [NonEvent] - public void AmqpTransactionDeclared(string localTransactionId, ArraySegment amqpTransactionId) - { - if (this.IsEnabled()) - { - this.AmqpTransactionDeclared(localTransactionId, amqpTransactionId.GetAsciiString()); - } - } - - [Event(109, Level = EventLevel.Informational, Message = "AmqpTransactionDeclared for LocalTransactionId: {0} AmqpTransactionId: {1}.")] - public void AmqpTransactionDeclared(string transactionId, string amqpTransactionId) - { - this.WriteEvent(109, transactionId, amqpTransactionId); - } - - [NonEvent] - public void AmqpTransactionDischarged(string localTransactionId, ArraySegment amqpTransactionId, bool rollback) - { - if (this.IsEnabled()) - { - this.AmqpTransactionDischarged(localTransactionId, amqpTransactionId.GetAsciiString(), rollback); - } - } - - [Event(110, Level = EventLevel.Informational, Message = "AmqpTransactionDischarged for LocalTransactionId: {0} AmqpTransactionId: {1} Rollback: {2}.")] - public void AmqpTransactionDischarged(string transactionId, string amqpTransactionId, bool rollback) - { - this.WriteEvent(110, transactionId, amqpTransactionId, rollback); - } - - [NonEvent] - public void AmqpTransactionDischargeException(string transactionId, ArraySegment amqpTransactionId, Exception exception) - { - if (this.IsEnabled()) - { - this.AmqpTransactionDischargeException(transactionId, amqpTransactionId.GetAsciiString(), exception.ToString()); - } - } - - [Event(111, Level = EventLevel.Error, Message = "AmqpTransactionDischargeException for TransactionId: {0} AmqpTransactionId: {1} Exception: {2}.")] - public void AmqpTransactionDischargeException(string transactionId, string amqpTransactionId, string exception) - { - this.WriteEvent(111, transactionId, amqpTransactionId, exception); - } - - [NonEvent] - public void AmqpCreateControllerException(string connectionManager, Exception exception) - { - if (this.IsEnabled()) - { - this.AmqpCreateControllerException(connectionManager, exception.ToString()); - } - } - - [Event(112, Level = EventLevel.Error, Message = "AmqpCreateControllerException for ConnectionManager: {0} Exception: {1}.")] - public void AmqpCreateControllerException(string connectionManager, string exception) - { - this.WriteEvent(112, connectionManager, exception); - } - - [Event(113, Level = EventLevel.Informational, Message = "{0}: Management operation '{1}' for '{2}' started.")] - public void ManagementOperationStart(string clientId, string operationName, string details = "") - { - if (this.IsEnabled()) - { - this.WriteEvent(113, clientId, operationName, details); - } - } - - [Event(114, Level = EventLevel.Informational, Message = "{0}: Management operation '{1}' for '{2}' finished.")] - public void ManagementOperationEnd(string clientId, string operationName, string details = "") - { - if (this.IsEnabled()) - { - this.WriteEvent(114, clientId, operationName, details); - } - } - - [NonEvent] - public void ManagementOperationException(string clientId, string operationName, Exception exception) - { - if (this.IsEnabled()) - { - this.ManagementOperationException(clientId, operationName, exception.ToString()); - } - } - - [Event(115, Level = EventLevel.Error, Message = "{0}: Management operation '{1}' encountered exception: '{2}'.")] - public void ManagementOperationException(string clientId, string operationName, string exception) - { - this.WriteEvent(115, clientId, operationName, exception); - } - - [Event(116, Level = EventLevel.Informational, Message = "{0}: Management client created with operationTimeout:{1}, tokenProvider:{2}.")] - public void ManagementClientCreated(string clientId, double operationTimeout, string tokenProvider) - { - if (this.IsEnabled()) - { - this.WriteEvent(116, clientId, operationTimeout, tokenProvider); - } - } - - [Event(117, Level = EventLevel.Warning, Message = "[De]Serialization failed for object:{0}; Details:{1}")] - public void ManagementSerializationException(string objectName, string details = "") - { - if (this.IsEnabled()) - { - this.WriteEvent(117, objectName, details); - } - } - } - -#pragma warning disable SA1402 // File may only contain a single type - internal static class TraceHelper -#pragma warning restore SA1402 // File may only contain a single type - { - public static string GetAsciiString(this ArraySegment arraySegment) - { - return arraySegment.Array == null ? string.Empty : Encoding.ASCII.GetString(arraySegment.Array, arraySegment.Offset, arraySegment.Count); - } - } -} diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Primitives/TaskExtensionHelper.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Primitives/TaskExtensionHelper.cs index c13cbae76d9f..cd73814cc4d8 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Primitives/TaskExtensionHelper.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Primitives/TaskExtensionHelper.cs @@ -1,11 +1,12 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +using System; +using System.Threading.Tasks; +using Azure.Messaging.ServiceBus.Diagnostics; + namespace Azure.Messaging.ServiceBus.Primitives { - using System; - using System.Threading.Tasks; - internal static class TaskExtensionHelper { public static void Schedule(Func func) @@ -21,7 +22,7 @@ private static async Task ScheduleInternal(Func func) } catch (Exception ex) { - MessagingEventSource.Log.ScheduleTaskFailed(func, ex); + ServiceBusEventSource.Log.ScheduleTaskFailed(func, ex); } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs index 3af71ed42878..8a7ab38bc9c0 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs @@ -243,7 +243,7 @@ private async Task RenewMessageLock( } catch (Exception ex) when (!(ex is TaskCanceledException)) { - ServiceBusEventSource.Log.ProcesserRenewMessageLockException(_identifier, ex); + ServiceBusEventSource.Log.ProcessorRenewMessageLockException(_identifier, ex.ToString()); await HandleRenewLockException(ex, cancellationToken).ConfigureAwait(false); // if the error was not transient, break out of the loop @@ -321,7 +321,7 @@ protected async Task RaiseExceptionReceived(ProcessErrorEventArgs eventArgs) catch (Exception exception) { // don't bubble up exceptions raised from customer exception handler - MessagingEventSource.Log.ExceptionReceivedHandlerThrewException(exception); + ServiceBusEventSource.Log.ProcessorErrorHandlerThrewException(exception.ToString()); } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs index e5aa3a0bdf9c..93bd75fea634 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs @@ -146,6 +146,12 @@ private set /// after completion of message and result in a few false MessageLockLostExceptions temporarily. public TimeSpan MaxAutoLockRenewalDuration { get; } + /// + /// The instance of which can be mocked for testing. + /// + /// + internal ServiceBusEventSource Logger { get; set; } = ServiceBusEventSource.Log; + private readonly string[] _sessionIds; private readonly IList _receiverManagers = new List(); @@ -412,13 +418,15 @@ public virtual async Task StartProcessingAsync( cancellationToken.ThrowIfCancellationRequested(); if (ActiveReceiveTask == null) { - ServiceBusEventSource.Log.StartProcessingStart(Identifier); - await ProcessingStartStopSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); - ValidateMessageHandler(); - ValidateErrorHandler(); + Logger.StartProcessingStart(Identifier); + bool releaseGuard = false; try { + await ProcessingStartStopSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); + releaseGuard = true; + ValidateMessageHandler(); + ValidateErrorHandler(); cancellationToken.ThrowIfCancellationRequested(); InitializeReceiverManagers(); @@ -434,14 +442,17 @@ public virtual async Task StartProcessingAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.StartProcessingException(Identifier, exception); + Logger.StartProcessingException(Identifier, exception.ToString()); throw; } finally { - ProcessingStartStopSemaphore.Release(); + if (releaseGuard) + { + ProcessingStartStopSemaphore.Release(); + } } - ServiceBusEventSource.Log.StartProcessingComplete(Identifier); + Logger.StartProcessingComplete(Identifier); } else { @@ -517,14 +528,16 @@ private void ValidateMessageHandler() /// A instance to signal the request to cancel the stop operation. If the operation is successfully canceled, the will keep running. public virtual async Task StopProcessingAsync(CancellationToken cancellationToken = default) { - cancellationToken.ThrowIfCancellationRequested(); + bool releaseGuard = false; try { if (ActiveReceiveTask != null) { - ServiceBusEventSource.Log.StopProcessingStart(Identifier); + Logger.StopProcessingStart(Identifier); + cancellationToken.ThrowIfCancellationRequested(); await ProcessingStartStopSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); + releaseGuard = true; cancellationToken.ThrowIfCancellationRequested(); @@ -559,14 +572,17 @@ await receiverManager.CloseReceiverIfNeeded( } catch (Exception exception) { - ServiceBusEventSource.Log.StopProcessingException(Identifier, exception); + Logger.StopProcessingException(Identifier, exception.ToString()); throw; } finally { - ProcessingStartStopSemaphore.Release(); + if (releaseGuard) + { + ProcessingStartStopSemaphore.Release(); + } } - ServiceBusEventSource.Log.StopProcessingComplete(Identifier); + Logger.StopProcessingComplete(Identifier); } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs index c15149a815ce..46bd4b6532df 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs @@ -282,7 +282,7 @@ private async Task RenewSessionLock(CancellationTokenSource cancellationTokenSou catch (Exception ex) when (!(ex is TaskCanceledException)) { - ServiceBusEventSource.Log.ProcessorRenewSessionLockException(_identifier, ex); + ServiceBusEventSource.Log.ProcessorRenewSessionLockException(_identifier, ex.ToString()); await HandleRenewLockException(ex, cancellationToken).ConfigureAwait(false); // if the error was not transient, break out of the loop diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs index 70a2dd592e2f..6667e15dbaff 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs @@ -11,6 +11,7 @@ using Azure.Core; using Azure.Messaging.ServiceBus.Core; using Azure.Messaging.ServiceBus.Diagnostics; +using Azure.Messaging.ServiceBus.Primitives; namespace Azure.Messaging.ServiceBus { @@ -84,6 +85,12 @@ public class ServiceBusReceiver : IAsyncDisposable /// internal readonly TransportReceiver InnerReceiver; + /// + /// The instance of which can be mocked for testing. + /// + /// + internal ServiceBusEventSource Logger { get; set; } = ServiceBusEventSource.Log; + /// /// Initializes a new instance of the class. /// @@ -102,27 +109,42 @@ internal ServiceBusReceiver( ServiceBusReceiverOptions options, string sessionId = default) { - Argument.AssertNotNull(connection, nameof(connection)); - Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions)); - Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath)); - connection.ThrowIfClosed(); - - options = options?.Clone() ?? new ServiceBusReceiverOptions(); - Identifier = DiagnosticUtilities.GenerateIdentifier(entityPath); - _connection = connection; - _retryPolicy = connection.RetryOptions.ToRetryPolicy(); - ReceiveMode = options.ReceiveMode; - PrefetchCount = options.PrefetchCount; - EntityPath = entityPath; - IsSessionReceiver = isSessionEntity; - InnerReceiver = _connection.CreateTransportReceiver( - entityPath: EntityPath, - retryPolicy: _retryPolicy, - receiveMode: ReceiveMode, - prefetchCount: (uint)PrefetchCount, - identifier: Identifier, - sessionId: sessionId, - isSessionReceiver: IsSessionReceiver); + Type type = GetType(); + Logger.ClientCreateStart(type, connection?.FullyQualifiedNamespace, entityPath); + try + { + Argument.AssertNotNull(connection, nameof(connection)); + Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions)); + Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath)); + connection.ThrowIfClosed(); + options = options?.Clone() ?? new ServiceBusReceiverOptions(); + Identifier = DiagnosticUtilities.GenerateIdentifier(entityPath); + _connection = connection; + _retryPolicy = connection.RetryOptions.ToRetryPolicy(); + ReceiveMode = options.ReceiveMode; + PrefetchCount = options.PrefetchCount; + EntityPath = entityPath; + IsSessionReceiver = isSessionEntity; + InnerReceiver = _connection.CreateTransportReceiver( + entityPath: EntityPath, + retryPolicy: _retryPolicy, + receiveMode: ReceiveMode, + prefetchCount: (uint)PrefetchCount, + identifier: Identifier, + sessionId: sessionId, + isSessionReceiver: IsSessionReceiver); + if (!isSessionEntity) + { + // don't log client completion for session receiver here as it is not complete until + // the link is opened. + Logger.ClientCreateComplete(type, Identifier); + } + } + catch (Exception ex) + { + Logger.ClientCreateException(type, connection?.FullyQualifiedNamespace, entityPath, ex); + throw; + } } /// @@ -155,7 +177,7 @@ public virtual async Task> ReceiveBatchAsync( } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.ReceiveMessageStart(Identifier, maxMessages); + Logger.ReceiveMessageStart(Identifier, maxMessages); IList messages = null; try @@ -167,12 +189,12 @@ public virtual async Task> ReceiveBatchAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.ReceiveMessageException(Identifier, exception); + Logger.ReceiveMessageException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.ReceiveMessageComplete(Identifier, maxMessages); + Logger.ReceiveMessageComplete(Identifier, messages.Count); return messages; } @@ -308,8 +330,8 @@ private async Task> PeekBatchAtInternalAsync( { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.PeekMessageStart(Identifier, sequenceNumber, maxMessages); - IList messages = null; + Logger.PeekMessageStart(Identifier, sequenceNumber, maxMessages); + IList messages = new List(); try { @@ -321,12 +343,12 @@ private async Task> PeekBatchAtInternalAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.PeekMessageException(Identifier, exception); + Logger.PeekMessageException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.PeekMessageComplete(Identifier, maxMessages); + Logger.PeekMessageComplete(Identifier, messages.Count); return messages; } @@ -426,7 +448,10 @@ internal virtual async Task CompleteAsync( ThrowIfNotPeekLockMode(); cancellationToken.ThrowIfCancellationRequested(); var lockTokenList = lockTokens.ToList(); - ServiceBusEventSource.Log.CompleteMessageStart(Identifier, lockTokenList.Count, lockTokenList); + Logger.CompleteMessageStart( + Identifier, + lockTokenList.Count, + StringUtility.GetFormattedLockTokens(lockTokenList)); try { @@ -436,12 +461,12 @@ await InnerReceiver.CompleteAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.CompleteMessageException(Identifier, exception); + Logger.CompleteMessageException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.CompleteMessageComplete(Identifier); + Logger.CompleteMessageComplete(Identifier); } /// @@ -495,7 +520,7 @@ public virtual async Task AbandonAsync( Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); ThrowIfNotPeekLockMode(); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.AbandonMessageStart(Identifier, 1, lockToken); + Logger.AbandonMessageStart(Identifier, 1, lockToken); try { @@ -506,12 +531,12 @@ await InnerReceiver.AbandonAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.AbandonMessageException(Identifier, exception); + Logger.AbandonMessageException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.AbandonMessageComplete(Identifier); + Logger.AbandonMessageComplete(Identifier); } /// @@ -650,7 +675,7 @@ private async Task DeadLetterInternalAsync( Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); cancellationToken.ThrowIfCancellationRequested(); ThrowIfNotPeekLockMode(); - ServiceBusEventSource.Log.DeadLetterMessageStart(Identifier, 1, lockToken); + Logger.DeadLetterMessageStart(Identifier, 1, lockToken); try { @@ -663,12 +688,12 @@ await InnerReceiver.DeadLetterAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.DeadLetterMessageException(Identifier, exception); + Logger.DeadLetterMessageException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.DeadLetterMessageComplete(Identifier); + Logger.DeadLetterMessageComplete(Identifier); } /// Indicates that the receiver wants to defer the processing for the message. @@ -724,7 +749,7 @@ public virtual async Task DeferAsync( Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); ThrowIfNotPeekLockMode(); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.DeferMessageStart(Identifier, 1, lockToken); + Logger.DeferMessageStart(Identifier, 1, lockToken); try { @@ -735,12 +760,12 @@ await InnerReceiver.DeferAsync( } catch (Exception ex) { - ServiceBusEventSource.Log.DeferMessageException(Identifier, ex); + Logger.DeferMessageException(Identifier, ex.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.DeferMessageComplete(Identifier); + Logger.DeferMessageComplete(Identifier); } /// @@ -807,7 +832,7 @@ public virtual async Task> ReceiveDeferredMessa Argument.AssertNotNullOrEmpty(sequenceNumbers, nameof(sequenceNumbers)); cancellationToken.ThrowIfCancellationRequested(); var sequenceNumbersList = sequenceNumbers.ToList(); - ServiceBusEventSource.Log.ReceiveDeferredMessageStart(Identifier, sequenceNumbersList.Count, sequenceNumbersList); + Logger.ReceiveDeferredMessageStart(Identifier, sequenceNumbersList.Count, sequenceNumbersList); IList deferredMessages = null; try @@ -818,12 +843,12 @@ public virtual async Task> ReceiveDeferredMessa } catch (Exception exception) { - ServiceBusEventSource.Log.ReceiveDeferredMessageException(Identifier, exception); + Logger.ReceiveDeferredMessageException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.ReceiveDeferredMessageStop(Identifier, sequenceNumbersList.Count); + Logger.ReceiveDeferredMessageComplete(Identifier, sequenceNumbersList.Count); return deferredMessages; } @@ -873,7 +898,7 @@ public virtual async Task RenewMessageLockAsync( ThrowIfNotPeekLockMode(); ThrowIfSessionReceiver(); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.RenewMessageLockStart(Identifier, 1, lockToken); + Logger.RenewMessageLockStart(Identifier, 1, lockToken); DateTimeOffset lockedUntil; try { @@ -883,12 +908,12 @@ public virtual async Task RenewMessageLockAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.RenewMessageLockException(Identifier, exception); + Logger.RenewMessageLockException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.RenewMessageLockComplete(Identifier); + Logger.RenewMessageLockComplete(Identifier); return lockedUntil; } @@ -912,19 +937,20 @@ private void ThrowIfSessionReceiver() public virtual async ValueTask DisposeAsync() { IsDisposed = true; + Type clientType = GetType(); - ServiceBusEventSource.Log.ClientDisposeStart(typeof(ServiceBusReceiver), Identifier); + Logger.ClientDisposeStart(clientType, Identifier); try { await InnerReceiver.CloseAsync(CancellationToken.None).ConfigureAwait(false); } catch (Exception ex) { - ServiceBusEventSource.Log.ClientDisposeException(typeof(ServiceBusReceiver), Identifier, ex); + Logger.ClientDisposeException(clientType, Identifier, ex); throw; } - ServiceBusEventSource.Log.ClientDisposeComplete(typeof(ServiceBusSender), Identifier); + Logger.ClientDisposeComplete(clientType, Identifier); } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusSessionReceiver.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusSessionReceiver.cs index a05f2d82bd23..ba2062706fbd 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusSessionReceiver.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusSessionReceiver.cs @@ -7,6 +7,7 @@ using Azure.Messaging.ServiceBus.Diagnostics; using Azure.Messaging.ServiceBus.Core; using Azure.Core; +using Microsoft.Identity.Client; namespace Azure.Messaging.ServiceBus { @@ -45,14 +46,21 @@ internal static async Task CreateSessionReceiverAsync ServiceBusReceiverOptions options = default, CancellationToken cancellationToken = default) { - var receiver = new ServiceBusSessionReceiver( connection: connection, entityPath: entityPath, options: options, sessionId: sessionId); - - await receiver.OpenLinkAsync(cancellationToken).ConfigureAwait(false); + try + { + await receiver.OpenLinkAsync(cancellationToken).ConfigureAwait(false); + } + catch (Exception ex) + { + receiver.Logger.ClientCreateException(typeof(ServiceBusSessionReceiver), receiver.FullyQualifiedNamespace, entityPath, ex); + throw; + } + receiver.Logger.ClientCreateComplete(typeof(ServiceBusSessionReceiver), receiver.Identifier); return receiver; } @@ -91,7 +99,7 @@ public virtual async Task GetSessionStateAsync(CancellationToken cancell { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSessionReceiver)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.GetSessionStateStart(Identifier, SessionId); + Logger.GetSessionStateStart(Identifier, SessionId); byte[] sessionState = null; try @@ -100,12 +108,12 @@ public virtual async Task GetSessionStateAsync(CancellationToken cancell } catch (Exception exception) { - ServiceBusEventSource.Log.GetSessionStateException(Identifier, exception); + Logger.GetSessionStateException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.GetSessionStateComplete(Identifier); + Logger.GetSessionStateComplete(Identifier); return sessionState; } @@ -125,7 +133,7 @@ public virtual async Task SetSessionStateAsync( { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSessionReceiver)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.SetSessionStateStart(Identifier, SessionId); + Logger.SetSessionStateStart(Identifier, SessionId); try { @@ -133,12 +141,12 @@ public virtual async Task SetSessionStateAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.SetSessionStateException(Identifier, exception); + Logger.SetSessionStateException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.SetSessionStateComplete(Identifier); + Logger.SetSessionStateComplete(Identifier); } /// @@ -161,7 +169,7 @@ public virtual async Task RenewSessionLockAsync(CancellationToken cancellationTo { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSessionReceiver)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.RenewSessionLockStart(Identifier, SessionId); + Logger.RenewSessionLockStart(Identifier, SessionId); try { @@ -169,12 +177,12 @@ public virtual async Task RenewSessionLockAsync(CancellationToken cancellationTo } catch (Exception exception) { - ServiceBusEventSource.Log.RenewSessionLockException(Identifier, exception); + Logger.RenewSessionLockException(Identifier, exception.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.RenewSessionLockComplete(Identifier); + Logger.RenewSessionLockComplete(Identifier); } } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/RuleManager/ServiceBusRuleManager.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/RuleManager/ServiceBusRuleManager.cs index 6f194b526738..8fc032bf3148 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/RuleManager/ServiceBusRuleManager.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/RuleManager/ServiceBusRuleManager.cs @@ -73,7 +73,8 @@ internal ServiceBusRuleManager( SubscriptionPath = subscriptionPath; InnerRuleManager = _connection.CreateTransportRuleManager( subscriptionPath: SubscriptionPath, - retryPolicy: connection.RetryOptions.ToRetryPolicy()); + retryPolicy: connection.RetryOptions.ToRetryPolicy(), + identifier: Identifier); } /// @@ -133,7 +134,7 @@ await InnerRuleManager.AddRuleAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.AddRuleException(Identifier, exception); + ServiceBusEventSource.Log.AddRuleException(Identifier, exception.ToString()); throw; } @@ -166,7 +167,7 @@ await InnerRuleManager.RemoveRuleAsync( } catch (Exception exception) { - ServiceBusEventSource.Log.RemoveRuleException(Identifier, exception); + ServiceBusEventSource.Log.RemoveRuleException(Identifier, exception.ToString()); throw; } @@ -195,7 +196,7 @@ public virtual async Task> GetRulesAsync(CancellationToke } catch (Exception exception) { - ServiceBusEventSource.Log.GetRuleException(Identifier, exception); + ServiceBusEventSource.Log.GetRuleException(Identifier, exception.ToString()); throw; } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs index b4c8d122f887..8a575fe71470 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs @@ -48,6 +48,12 @@ public class ServiceBusSender : IAsyncDisposable /// public bool IsDisposed { get; private set; } = false; + /// + /// The instance of which can be mocked for testing. + /// + /// + internal ServiceBusEventSource Logger { get; set; } = ServiceBusEventSource.Log; + /// /// In the case of a via-sender, the message is sent to via ; null otherwise. /// @@ -92,21 +98,32 @@ internal ServiceBusSender( ServiceBusSenderOptions options, ServiceBusConnection connection) { - Argument.AssertNotNull(connection, nameof(connection)); - Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions)); - Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath)); - connection.ThrowIfClosed(); - - options = options?.Clone() ?? new ServiceBusSenderOptions(); - EntityPath = entityPath; - ViaEntityPath = options.ViaQueueOrTopicName; - Identifier = DiagnosticUtilities.GenerateIdentifier(EntityPath); - _connection = connection; - _retryPolicy = _connection.RetryOptions.ToRetryPolicy(); - _innerSender = _connection.CreateTransportSender( - entityPath, - ViaEntityPath, - _retryPolicy); + Logger.ClientCreateStart(typeof(ServiceBusSender), connection?.FullyQualifiedNamespace, entityPath); + try + { + Argument.AssertNotNull(connection, nameof(connection)); + Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions)); + Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath)); + connection.ThrowIfClosed(); + + options = options?.Clone() ?? new ServiceBusSenderOptions(); + EntityPath = entityPath; + ViaEntityPath = options.ViaQueueOrTopicName; + Identifier = DiagnosticUtilities.GenerateIdentifier(EntityPath); + _connection = connection; + _retryPolicy = _connection.RetryOptions.ToRetryPolicy(); + _innerSender = _connection.CreateTransportSender( + entityPath, + ViaEntityPath, + _retryPolicy, + Identifier); + } + catch (Exception ex) + { + Logger.ClientCreateException(typeof(ServiceBusSender), connection?.FullyQualifiedNamespace, entityPath, ex); + throw; + } + Logger.ClientCreateComplete(typeof(ServiceBusSender), Identifier); } /// @@ -161,7 +178,7 @@ public virtual async Task SendAsync( } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.SendMessageStart(Identifier, messageCount: messageList.Count); + Logger.SendMessageStart(Identifier, messageCount: messageList.Count); try { await _innerSender.SendAsync( @@ -170,11 +187,11 @@ await _innerSender.SendAsync( } catch (Exception ex) { - ServiceBusEventSource.Log.SendMessageException(Identifier, ex); + Logger.SendMessageException(Identifier, ex.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.SendMessageComplete(Identifier); + Logger.SendMessageComplete(Identifier); } /// @@ -218,7 +235,7 @@ public virtual async ValueTask CreateBatchAsync( Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); options = options?.Clone() ?? new CreateBatchOptions(); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.CreateMessageBatchStart(Identifier); + Logger.CreateMessageBatchStart(Identifier); ServiceBusMessageBatch batch; try { @@ -227,11 +244,11 @@ public virtual async ValueTask CreateBatchAsync( } catch (Exception ex) { - ServiceBusEventSource.Log.CreateMessageBatchException(Identifier, ex); + Logger.CreateMessageBatchException(Identifier, ex.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.CreateMessageBatchComplete(Identifier); + Logger.CreateMessageBatchComplete(Identifier); return batch; } @@ -252,7 +269,7 @@ public virtual async Task SendAsync( Argument.AssertNotNull(messageBatch, nameof(messageBatch)); Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.SendMessageStart(Identifier, messageBatch.Count); + Logger.SendMessageStart(Identifier, messageBatch.Count); try { messageBatch.Lock(); @@ -260,7 +277,7 @@ public virtual async Task SendAsync( } catch (Exception ex) { - ServiceBusEventSource.Log.SendMessageException(Identifier, ex); + Logger.SendMessageException(Identifier, ex.ToString()); throw; } finally @@ -269,7 +286,7 @@ public virtual async Task SendAsync( } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.SendMessageComplete(Identifier); + Logger.SendMessageComplete(Identifier); } /// @@ -290,7 +307,7 @@ public virtual async Task ScheduleMessageAsync( Argument.AssertNotNull(message, nameof(message)); Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.ScheduleMessageStart(Identifier, scheduledEnqueueTime); + Logger.ScheduleMessageStart(Identifier, scheduledEnqueueTime.ToString()); long sequenceNumber; try @@ -300,12 +317,12 @@ public virtual async Task ScheduleMessageAsync( } catch (Exception ex) { - ServiceBusEventSource.Log.ScheduleMessageException(Identifier, ex); + Logger.ScheduleMessageException(Identifier, ex.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.ScheduleMessageComplete(Identifier); + Logger.ScheduleMessageComplete(Identifier); return sequenceNumber; } @@ -320,7 +337,7 @@ public virtual async Task CancelScheduledMessageAsync( { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.CancelScheduledMessageStart(Identifier, sequenceNumber); + Logger.CancelScheduledMessageStart(Identifier, sequenceNumber); try { @@ -328,12 +345,12 @@ public virtual async Task CancelScheduledMessageAsync( } catch (Exception ex) { - ServiceBusEventSource.Log.CancelScheduledMessageException(Identifier, ex); + Logger.CancelScheduledMessageException(Identifier, ex.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - ServiceBusEventSource.Log.CancelScheduledMessageComplete(Identifier); + Logger.CancelScheduledMessageComplete(Identifier); } /// @@ -347,7 +364,7 @@ public virtual async ValueTask DisposeAsync() { IsDisposed = true; - ServiceBusEventSource.Log.ClientDisposeStart(typeof(ServiceBusSender), Identifier); + Logger.ClientDisposeStart(typeof(ServiceBusSender), Identifier); try { @@ -355,11 +372,11 @@ public virtual async ValueTask DisposeAsync() } catch (Exception ex) { - ServiceBusEventSource.Log.ClientDisposeException(typeof(ServiceBusSender), Identifier, ex); + Logger.ClientDisposeException(typeof(ServiceBusSender), Identifier, ex); throw; } - ServiceBusEventSource.Log.ClientDisposeComplete(typeof(ServiceBusSender), Identifier); + Logger.ClientDisposeComplete(typeof(ServiceBusSender), Identifier); } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusConnection.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusConnection.cs index d141de40e696..4213508f9eda 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusConnection.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusConnection.cs @@ -211,8 +211,9 @@ public virtual async Task CloseAsync(CancellationToken cancellationToken = defau internal virtual TransportSender CreateTransportSender( string entityPath, string viaEntityPath, - ServiceBusRetryPolicy retryPolicy) => - _innerClient.CreateSender(entityPath, viaEntityPath, retryPolicy); + ServiceBusRetryPolicy retryPolicy, + string identifier) => + _innerClient.CreateSender(entityPath, viaEntityPath, retryPolicy, identifier); internal virtual TransportReceiver CreateTransportReceiver( string entityPath, @@ -233,8 +234,9 @@ internal virtual TransportReceiver CreateTransportReceiver( internal virtual TransportRuleManager CreateTransportRuleManager( string subscriptionPath, - ServiceBusRetryPolicy retryPolicy) => - _innerClient.CreateRuleManager(subscriptionPath, retryPolicy); + ServiceBusRetryPolicy retryPolicy, + string identifier) => + _innerClient.CreateRuleManager(subscriptionPath, retryPolicy, identifier); /// /// Builds a Service Bus client specific to the protocol and transport specified by the diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusRetryPolicy.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusRetryPolicy.cs index 957a5326f375..6c4b2a4a810e 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusRetryPolicy.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/ServiceBusRetryPolicy.cs @@ -46,6 +46,12 @@ public abstract class ServiceBusRetryPolicy /// private string ServerBusyExceptionMessage { get; set; } + /// + /// The instance of which can be mocked for testing. + /// + /// + internal ServiceBusEventSource Logger { get; set; } = ServiceBusEventSource.Log; + /// /// Calculates the amount of time to allow the current attempt for an operation to /// complete before considering it to be timed out. @@ -113,62 +119,55 @@ internal async Task RunOperation( { var failedAttemptCount = 0; - try + + TimeSpan tryTimeout = CalculateTryTimeout(0); + if (IsServerBusy && tryTimeout < ServerBusyBaseSleepTime) { - TimeSpan tryTimeout = CalculateTryTimeout(0); - if (IsServerBusy && tryTimeout < ServerBusyBaseSleepTime) + // We are in a server busy state before we start processing. + // Since ServerBusyBaseSleepTime > remaining time for the operation, we don't wait for the entire Sleep time. + await Task.Delay(tryTimeout, cancellationToken).ConfigureAwait(false); + throw new ServiceBusException( + ServerBusyExceptionMessage, + ServiceBusException.FailureReason.ServiceBusy); + } + while (!cancellationToken.IsCancellationRequested) + { + if (IsServerBusy) { - // We are in a server busy state before we start processing. - // Since ServerBusyBaseSleepTime > remaining time for the operation, we don't wait for the entire Sleep time. - await Task.Delay(tryTimeout, cancellationToken).ConfigureAwait(false); - throw new ServiceBusException( - ServerBusyExceptionMessage, - ServiceBusException.FailureReason.ServiceBusy); + await Task.Delay(ServerBusyBaseSleepTime, cancellationToken).ConfigureAwait(false); } - while (!cancellationToken.IsCancellationRequested) + + try { - if (IsServerBusy) - { - await Task.Delay(ServerBusyBaseSleepTime, cancellationToken).ConfigureAwait(false); - } + await operation(tryTimeout).ConfigureAwait(false); + return; + } + + catch (Exception ex) + { + Exception activeEx = AmqpExceptionHelper.TranslateException(ex); - try + // Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop. + // Otherwise, throw the translated exception. + + ++failedAttemptCount; + TimeSpan? retryDelay = CalculateRetryDelay(activeEx, failedAttemptCount); + if (retryDelay.HasValue && !scope.IsDisposed && !cancellationToken.IsCancellationRequested) { - await operation(tryTimeout).ConfigureAwait(false); - return; + Logger.RunOperationExceptionEncountered(activeEx.ToString()); + await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false); + tryTimeout = CalculateTryTimeout(failedAttemptCount); } - - catch (Exception ex) + else { - Exception activeEx = AmqpExceptionHelper.TranslateException(ex); - - // Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop. - // Otherwise, throw the translated exception. - - ++failedAttemptCount; - TimeSpan? retryDelay = CalculateRetryDelay(activeEx, failedAttemptCount); - if (retryDelay.HasValue && !scope.IsDisposed && !cancellationToken.IsCancellationRequested) - { - ServiceBusEventSource.Log.RunOperationExceptionEncountered(activeEx); - await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false); - tryTimeout = CalculateTryTimeout(failedAttemptCount); - } - else - { - ExceptionDispatchInfo.Capture(activeEx) - .Throw(); - } + ExceptionDispatchInfo.Capture(activeEx) + .Throw(); } } - // If no value has been returned nor exception thrown by this point, - // then cancellation has been requested. - throw new TaskCanceledException(); - } - catch (Exception ex) - { - ServiceBusEventSource.Log.RunOperationExceptionEncountered(ex); - throw; } + // If no value has been returned nor exception thrown by this point, + // then cancellation has been requested. + throw new TaskCanceledException(); } internal void SetServerBusy(string exceptionMessage) diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs index 79e7b31c318d..d2deac1e96de 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs @@ -6,9 +6,9 @@ using System.Threading; using System.Threading.Tasks; using Azure.Core; -using Azure.Messaging.ServiceBus; using Azure.Messaging.ServiceBus.Amqp; using Azure.Messaging.ServiceBus.Core; +using Azure.Messaging.ServiceBus.Diagnostics; using Microsoft.Azure.Amqp; using Microsoft.Azure.Amqp.Framing; using Moq; @@ -109,33 +109,6 @@ public async Task CloseMarksTheConsumerAsClosed() Assert.That(receiver.IsClosed, Is.True, "The receiver should be marked as closed after closing"); } - ///// - ///// Verifies functionality of the - ///// method. - ///// - ///// - //[Test] - //[TestCase(-32768)] - //[TestCase(-1)] - //[TestCase(0)] - //public void ReceiveAsyncValidatesTheMaximumMessageCount(int count) - //{ - // var eventHub = "eventHubName"; - // var consumerGroup = "$DEFAULT"; - // var partition = "3"; - // var eventPosition = EventPosition.FromOffset(123); - // var retryPolicy = new BasicRetryPolicy(new EventHubsRetryOptions()); - // var retriableException = new EventHubsException(true, "Test"); - // var mockConverter = new Mock(); - // var mockCredential = new Mock(); - // var mockScope = new Mock(); - - // using var cancellationSource = new CancellationTokenSource(); - - // var consumer = new AmqpReceiver(eventHub, consumerGroup, partition, eventPosition, true, null, null, mockScope.Object, Mock.Of(), retryPolicy); - // Assert.That(async () => await consumer.ReceiveAsync(count, null, cancellationSource.Token), Throws.InstanceOf()); - //} - /// /// Verifies functionality of the /// method. @@ -189,6 +162,7 @@ public void ReceiveAsyncAppliesTheRetryPolicy(ServiceBusRetryOptions retryOption It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) .Throws(retriableException); @@ -206,6 +180,7 @@ public void ReceiveAsyncAppliesTheRetryPolicy(ServiceBusRetryOptions retryOption It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny()), Times.Exactly(1 + retryOptions.MaxRetries)); } @@ -243,6 +218,7 @@ public void ReceiveAsyncConsidersOperationCanceledExceptionAsRetriable(ServiceBu It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) .Throws(retriableException); @@ -260,6 +236,7 @@ public void ReceiveAsyncConsidersOperationCanceledExceptionAsRetriable(ServiceBu It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny()), Times.Exactly(1 + retryOptions.MaxRetries)); } @@ -276,7 +253,11 @@ public void ReceiveAsyncAppliesTheRetryPolicyForAmqpErrors(ServiceBusRetryOption { var entityName = "entityName"; var tokenValue = "123ABC"; - var retryPolicy = new BasicRetryPolicy(retryOptions); + var mockLogger = new Mock(); + var retryPolicy = new BasicRetryPolicy(retryOptions) + { + Logger = mockLogger.Object + }; var retriableException = new Error { Condition = AmqpClientConstants.ServerBusyError.ToString() @@ -301,6 +282,7 @@ public void ReceiveAsyncAppliesTheRetryPolicyForAmqpErrors(ServiceBusRetryOption It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) .Throws(retriableException); @@ -318,8 +300,14 @@ public void ReceiveAsyncAppliesTheRetryPolicyForAmqpErrors(ServiceBusRetryOption It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny()), Times.Exactly(1 + retryOptions.MaxRetries)); + + mockLogger + .Verify( + log => log.RunOperationExceptionEncountered(It.IsAny()), + Times.Exactly(retryOptions.MaxRetries)); } /// @@ -354,6 +342,7 @@ public void ReceiveAsyncDetectsAnEmbeddedErrorForOperationCanceled() It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) .Throws(exception); @@ -371,6 +360,7 @@ public void ReceiveAsyncDetectsAnEmbeddedErrorForOperationCanceled() It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny()), Times.Once()); } @@ -408,6 +398,7 @@ public void ReceiveAsyncDetectsAnEmbeddedAmqpErrorForOperationCanceled() It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) .Throws(exception); @@ -425,6 +416,7 @@ public void ReceiveAsyncDetectsAnEmbeddedAmqpErrorForOperationCanceled() It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny()), Times.Once()); } @@ -461,6 +453,7 @@ public void ReceiveAsyncDoesntRetryOnTaskCanceled() It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) .Throws(exception); @@ -478,6 +471,7 @@ public void ReceiveAsyncDoesntRetryOnTaskCanceled() It.IsAny(), It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny()), Times.Once()); } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs index bbbbf4f547cd..95c117209583 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs @@ -37,6 +37,7 @@ public async Task GetChildClientFromClosedParentClientThrows(bool useSessions) Assert.True(Encoding.UTF8.GetString(receivedMessage.Body.ToArray()) == Encoding.UTF8.GetString(message.Body.ToArray())); await client.DisposeAsync(); + Assert.IsTrue(client.IsDisposed); if (!useSessions) { Assert.Throws(() => client.CreateReceiver(scope.QueueName)); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientTests.cs index 8ed99e777f1a..7def1f469dbd 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientTests.cs @@ -228,6 +228,21 @@ public void CreateSenderAllowsIfEntityNamesAreEqual() Assert.That(() => client.CreateSender(entityName), Throws.Nothing, "Get sender should allow the same entity name in multiple places"); } + /// + /// Verifies functionality of the + /// + /// + [Test] + public void ValidateClientProperties() + { + var entityName = "myQueue"; + var fakeConnection = $"Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessKeyName=DummyKey;SharedAccessKey=[not_real];EntityPath={ entityName }"; + ServiceBusClient client = new ServiceBusClient(fakeConnection); + Assert.AreEqual("not-real.servicebus.windows.net", client.FullyQualifiedNamespace); + Assert.IsNotNull(client.Identifier); + Assert.IsFalse(client.IsDisposed); + } + /// /// Allows for the options used by the client to be exposed for testing purposes. /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs new file mode 100644 index 000000000000..1f3da362ff46 --- /dev/null +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs @@ -0,0 +1,207 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.Collections.Generic; +using System.Diagnostics.Tracing; +using System.Linq; +using System.Threading.Tasks; +using System.Transactions; +using Azure.Core.TestFramework; +using Azure.Messaging.ServiceBus.Diagnostics; +using NUnit.Framework; + +namespace Azure.Messaging.ServiceBus.Tests.Diagnostics +{ + [NonParallelizable] + public class EventSourceLiveTests : ServiceBusLiveTestBase + { + private TestEventListener _listener; + + [SetUp] + public void Setup() + { + _listener = new TestEventListener(); + _listener.EnableEvents(ServiceBusEventSource.Log, EventLevel.Verbose); + } + + [TearDown] + public void TearDown() + { + _listener.Dispose(); + } + + [Test] + public async Task LogsEvents() + { + await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) + { + await using var client = GetNoRetryClient(); + _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.CreateBatchAsync(); + _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier)); + + IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); + + await sender.SendAsync(batch); + _listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, 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.CreateSessionReceiverAsync(scope.QueueName), + Throws.InstanceOf()); + _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.ReceiveBatchAsync(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.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.PeekBatchAsync(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.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier)); + + await sender.DisposeAsync(); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier)); + + await client.DisposeAsync(); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier)); + } + } + + [Test] + public async Task LogsSessionEvents() + { + await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) + { + await using var client = GetNoRetryClient(); + _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.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.FullyQualifiedNamespace) && e.Payload.Contains(sender.EntityPath)); + using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier)); + + IEnumerable messages = AddMessages(batch, messageCount, "sessionId").AsEnumerable(); + + await sender.SendAsync(batch); + _listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, 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)); + + var receiver = client.CreateReceiver(scope.QueueName); + _listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace)); + + // can't use a non-session receiver for session queue + Assert.That( + async () => await receiver.ReceiveAsync(), + Throws.InstanceOf()); + + _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(receiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkExceptionEvent, e => e.Payload.Contains(receiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ReceiveMessageStartEvent, e => e.Payload.Contains(receiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ReceiveMessageExceptionEvent, e => e.Payload.Contains(receiver.Identifier)); + + var sessionReceiver = await client.CreateSessionReceiverAsync(scope.QueueName); + _listener.EventsById(ServiceBusEventSource.ClientCreateStartEvent).Where(e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace)).Any(); + _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + + var msg = await sessionReceiver.ReceiveAsync(); + _listener.SingleEventById(ServiceBusEventSource.ReceiveMessageStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + + msg = await sessionReceiver.PeekAsync(); + _listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.PeekMessageStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.PeekMessageCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); + + await receiver.DisposeAsync(); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier)); + + await sessionReceiver.DisposeAsync(); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(sessionReceiver.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(sessionReceiver.Identifier)); + + await sender.DisposeAsync(); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier)); + + await client.DisposeAsync(); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier)); + _listener.SingleEventById(ServiceBusEventSource.ClientDisposeCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier)); + } + } + + [Test] + public async Task LogsTransactionEvents() + { + 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(); + + using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) + { + await sender.SendAsync(message); + ts.Complete(); + } + _listener.SingleEventById(ServiceBusEventSource.TransactionDeclaredEvent); + _listener.SingleEventById(ServiceBusEventSource.TransactionDischargedEvent); + }; + } + } +} diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs new file mode 100644 index 000000000000..6427e0bf81eb --- /dev/null +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs @@ -0,0 +1,1218 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using Azure.Messaging.ServiceBus.Core; +using Azure.Messaging.ServiceBus.Diagnostics; +using Azure.Messaging.ServiceBus.Primitives; +using Azure.Messaging.ServiceBus.Tests.Infrastructure; +using Moq; +using NUnit.Framework; + +namespace Azure.Messaging.ServiceBus.Tests.Diagnostics +{ + public class EventSourceTests : ServiceBusTestBase + { + [Test] + public async Task SendSingleMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + await sender.SendAsync(GetMessage()); + + mockLogger + .Verify( + log => log.SendMessageStart( + sender.Identifier, + 1), + Times.Once); + mockLogger + .Verify( + log => log.SendMessageComplete( + sender.Identifier), + Times.Once); + } + + [Test] + public async Task SendListOfMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + await sender.SendAsync(GetMessages(5)); + + mockLogger + .Verify( + log => log.SendMessageStart( + sender.Identifier, + 5), + Times.Once); + mockLogger + .Verify( + log => log.SendMessageComplete( + sender.Identifier), + Times.Once); + } + + [Test] + public void SendMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + + mockTransportSender.Setup( + sender => sender.SendAsync( + It.IsAny>(), + It.IsAny())) + .Throws(new Exception()); + + Assert.That( + async () => await sender.SendAsync(GetMessage()), + Throws.InstanceOf()); + mockLogger + .Verify( + log => log.SendMessageStart( + sender.Identifier, + 1), + Times.Once); + mockLogger + .Verify( + log => log.SendMessageException( + sender.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task SendBatchOfMessagesLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockTransportBatch = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + + mockTransportBatch + .Setup(transport => transport.Count) + .Returns(3); + + mockTransportSender.Setup( + sender => sender.CreateBatchAsync( + It.IsAny(), + It.IsAny())) + .Returns(new ValueTask(mockTransportBatch.Object)); + + var batch = await sender.CreateBatchAsync(); + await sender.SendAsync(batch); + mockLogger + .Verify( + log => log.CreateMessageBatchStart( + sender.Identifier), + Times.Once); + mockLogger + .Verify( + log => log.CreateMessageBatchComplete( + sender.Identifier), + Times.Once); + mockLogger + .Verify( + log => log.SendMessageStart( + sender.Identifier, + 3), + Times.Once); + mockLogger + .Verify( + log => log.SendMessageComplete( + sender.Identifier), + Times.Once); + } + + [Test] + public async Task ScheduleMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + 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); + } + + [Test] + public void ScheduleMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + + mockTransportSender.Setup( + sender => sender.ScheduleMessageAsync( + It.IsAny(), + It.IsAny())) + .Throws(new Exception()); + + var scheduleTime = DateTimeOffset.UtcNow.AddMinutes(1); + Assert.That( + async () => await sender.ScheduleMessageAsync(GetMessage(), scheduleTime), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.ScheduleMessageStart( + sender.Identifier, + scheduleTime.ToString()), + Times.Once); + mockLogger + .Verify( + log => log.ScheduleMessageException( + sender.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task CancelScheduleMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + var sequenceNumber = 1; + await sender.CancelScheduledMessageAsync(sequenceNumber); + + mockLogger + .Verify( + log => log.CancelScheduledMessageStart( + sender.Identifier, + sequenceNumber), + Times.Once); + mockLogger + .Verify( + log => log.CancelScheduledMessageComplete( + sender.Identifier), + Times.Once); + } + + [Test] + public void CancelScheduleMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportSender = new Mock(); + var mockConnection = GetMockConnection(mockTransportSender); + + var sender = new ServiceBusSender("queueName", new ServiceBusSenderOptions(), mockConnection.Object) + { + Logger = mockLogger.Object + }; + var sequenceNumber = 1; + + mockTransportSender.Setup( + sender => sender.CancelScheduledMessageAsync( + sequenceNumber, + It.IsAny())) + .Throws(new Exception()); + + Assert.That( + async () => await sender.CancelScheduledMessageAsync(sequenceNumber), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.CancelScheduledMessageStart( + sender.Identifier, + sequenceNumber), + Times.Once); + mockLogger + .Verify( + log => log.CancelScheduledMessageException( + sender.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task ReceiveSingleMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.ReceiveBatchAsync( + 1, + It.IsAny(), + It.IsAny())) + .Returns( + Task.FromResult((IList) + new List { new ServiceBusReceivedMessage() })); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + + await receiver.ReceiveAsync(); + + mockLogger + .Verify( + log => log.ReceiveMessageStart( + receiver.Identifier, + 1), + Times.Once); + mockLogger + .Verify( + log => log.ReceiveMessageComplete( + receiver.Identifier, + 1), + Times.Once); + } + + [Test] + public async Task ReceiveBatchOfMessagesLogsEvents() + { + var mockLogger = new Mock(); + var maxMessages = 4; + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.ReceiveBatchAsync( + maxMessages, + It.IsAny(), + It.IsAny())) + .Returns( + Task.FromResult((IList) + new List { new ServiceBusReceivedMessage(), + new ServiceBusReceivedMessage()})); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msgs = await receiver.ReceiveBatchAsync(maxMessages: maxMessages); + + mockLogger + .Verify( + log => log.ReceiveMessageStart( + receiver.Identifier, + // the amount requested + maxMessages), + Times.Once); + mockLogger + .Verify( + log => log.ReceiveMessageComplete( + receiver.Identifier, + // the amount we actually received + msgs.Count), + Times.Once); + } + + [Test] + public void ReceiveMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.ReceiveBatchAsync( + 1, + It.IsAny(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + Assert.That( + async () => await receiver.ReceiveAsync(), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.ReceiveMessageStart( + receiver.Identifier, + 1), + Times.Once); + mockLogger + .Verify( + log => log.ReceiveMessageException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task PeekSingleMessageLogsEvents(bool specifySeqNumber) + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.PeekBatchAtAsync( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns( + Task.FromResult((IList) + new List { new ServiceBusReceivedMessage() })); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + var seqNumber = 5; + + if (specifySeqNumber) + { + await receiver.PeekAtAsync(seqNumber); + } + else + { + await receiver.PeekAsync(); + } + + mockLogger + .Verify( + log => log.PeekMessageStart( + receiver.Identifier, + specifySeqNumber ? (long?) seqNumber : null, + 1), + Times.Once); + mockLogger + .Verify( + log => log.PeekMessageComplete( + receiver.Identifier, + 1), + Times.Once); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task PeekBatchOfMessagesLogsEvents(bool specifySeqNumber) + { + var mockLogger = new Mock(); + var maxMessages = 4; + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.PeekBatchAtAsync( + It.IsAny(), + maxMessages, + It.IsAny())) + .Returns( + Task.FromResult((IList) + new List { new ServiceBusReceivedMessage(), + new ServiceBusReceivedMessage()})); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var seqNumber = 5; + IList msgs; + if (specifySeqNumber) + { + msgs = await receiver.PeekBatchAtAsync(seqNumber, maxMessages); + } + else + { + msgs = await receiver.PeekBatchAsync(maxMessages: maxMessages); + } + + mockLogger + .Verify( + log => log.PeekMessageStart( + receiver.Identifier, + specifySeqNumber ? (long?)seqNumber : null, + // the amount requested + maxMessages), + Times.Once); + mockLogger + .Verify( + log => log.PeekMessageComplete( + receiver.Identifier, + // the amount we actually received + msgs.Count), + Times.Once); + } + + [Test] + public void PeekMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.PeekBatchAtAsync( + It.IsAny(), + 1, + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + Assert.That( + async () => await receiver.PeekAsync(), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.PeekMessageStart( + receiver.Identifier, + null, + 1), + Times.Once); + mockLogger + .Verify( + log => log.PeekMessageException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task CompleteMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + await receiver.CompleteAsync(msg); + + mockLogger + .Verify( + log => log.CompleteMessageStart( + receiver.Identifier, + 1, + StringUtility.GetFormattedLockTokens(new string[] { msg.LockToken })), + Times.Once); + mockLogger + .Verify( + log => log.CompleteMessageComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void CompleteMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.CompleteAsync( + It.IsAny>(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + Assert.That( + async () => await receiver.CompleteAsync(msg), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.CompleteMessageStart( + receiver.Identifier, + 1, + StringUtility.GetFormattedLockTokens(new string[] { msg.LockToken })), + Times.Once); + mockLogger + .Verify( + log => log.CompleteMessageException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task DeferMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + await receiver.DeferAsync(msg); + + mockLogger + .Verify( + log => log.DeferMessageStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.DeferMessageComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void DeferMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.CompleteAsync( + It.IsAny>(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + Assert.That( + async () => await receiver.CompleteAsync(msg), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.CompleteMessageStart( + receiver.Identifier, + 1, + StringUtility.GetFormattedLockTokens(new string[] { msg.LockToken })), + Times.Once); + mockLogger + .Verify( + log => log.CompleteMessageException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task DeadLetterMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + await receiver.DeadLetterAsync(msg); + + mockLogger + .Verify( + log => log.DeadLetterMessageStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.DeadLetterMessageComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void DeadLetterMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.DeadLetterAsync( + It.IsAny(), + It.IsAny(), + It.IsAny(), + It.IsAny>(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + Assert.That( + async () => await receiver.DeadLetterAsync(msg), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.DeadLetterMessageStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.DeadLetterMessageException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task AbandonMessageLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + await receiver.AbandonAsync(msg); + + mockLogger + .Verify( + log => log.AbandonMessageStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.AbandonMessageComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void AbandonMessageExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.AbandonAsync( + It.IsAny(), + It.IsAny>(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + Assert.That( + async () => await receiver.AbandonAsync(msg), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.AbandonMessageStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.AbandonMessageException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task RenewMessageLockLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + await receiver.RenewMessageLockAsync(msg); + + mockLogger + .Verify( + log => log.RenewMessageLockStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.RenewMessageLockComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void RenewMessageLockExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.RenewMessageLockAsync( + It.IsAny(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; + Assert.That( + async () => await receiver.RenewMessageLockAsync(msg), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.RenewMessageLockStart( + receiver.Identifier, + 1, + msg.LockToken), + Times.Once); + mockLogger + .Verify( + log => log.RenewMessageLockException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task RenewSessionLockLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + await receiver.RenewSessionLockAsync(); + + mockLogger + .Verify( + log => log.RenewSessionLockStart( + receiver.Identifier, + It.IsAny()), + Times.Once); + mockLogger + .Verify( + log => log.RenewSessionLockComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void RenewSessionLockExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.RenewSessionLockAsync( + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + Assert.That( + async () => await receiver.RenewSessionLockAsync(), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.RenewSessionLockStart( + receiver.Identifier, + It.IsAny()), + Times.Once); + mockLogger + .Verify( + log => log.RenewSessionLockException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task GetSessionStateLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + await receiver.GetSessionStateAsync(); + + mockLogger + .Verify( + log => log.GetSessionStateStart( + receiver.Identifier, + It.IsAny()), + Times.Once); + mockLogger + .Verify( + log => log.GetSessionStateComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void GetSessionStateExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.GetStateAsync( + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + Assert.That( + async () => await receiver.GetSessionStateAsync(), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.GetSessionStateStart( + receiver.Identifier, + It.IsAny()), + Times.Once); + mockLogger + .Verify( + log => log.GetSessionStateException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task SetSessionStateLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + await receiver.SetSessionStateAsync(null); + + mockLogger + .Verify( + log => log.SetSessionStateStart( + receiver.Identifier, + It.IsAny()), + Times.Once); + mockLogger + .Verify( + log => log.SetSessionStateComplete( + receiver.Identifier), + Times.Once); + } + + [Test] + public void SetSessionStateExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.SetStateAsync( + It.IsAny(), + It.IsAny())) + .Throws(new Exception()); + var receiver = new ServiceBusSessionReceiver(mockConnection.Object, "queueName", new ServiceBusReceiverOptions()) + { + Logger = mockLogger.Object + }; + + Assert.That( + async () => await receiver.SetSessionStateAsync(null), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.SetSessionStateStart( + receiver.Identifier, + It.IsAny()), + Times.Once); + mockLogger + .Verify( + log => log.SetSessionStateException( + receiver.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task StartStopProcessingLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.ReceiveBatchAsync( + 1, + It.IsAny(), + It.IsAny())) + .Returns(Task.FromResult((IList) new List() { new ServiceBusReceivedMessage() })); + var processor = new ServiceBusProcessor(mockConnection.Object, "queueName", false, new ServiceBusProcessorOptions + { + MaxAutoLockRenewalDuration = TimeSpan.Zero, + AutoComplete = false + }) + { + Logger = mockLogger.Object + }; + processor.ProcessErrorAsync += ExceptionHandler; + processor.ProcessMessageAsync += MessageHandler; + + async Task MessageHandler(ProcessMessageEventArgs arg) + { + // simulate IO + await Task.Delay(1000); + } + + await processor.StartProcessingAsync(); + + mockLogger + .Verify( + log => log.StartProcessingStart( + processor.Identifier), + Times.Once); + mockLogger + .Verify( + log => log.StartProcessingComplete( + processor.Identifier), + Times.Once); + + await processor.StopProcessingAsync(); + + mockLogger + .Verify( + log => log.StopProcessingStart( + processor.Identifier), + Times.Once); + mockLogger + .Verify( + log => log.StopProcessingComplete( + processor.Identifier), + Times.Once); + } + + [Test] + public void StartProcessingExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockConnection = new Mock(); + mockConnection.Setup( + connection => connection.RetryOptions) + .Returns(new ServiceBusRetryOptions()); + var processor = new ServiceBusProcessor(mockConnection.Object, "queueName", false, new ServiceBusProcessorOptions + { + AutoComplete = false, + MaxAutoLockRenewalDuration = TimeSpan.Zero + }) + { + Logger = mockLogger.Object + }; + + Assert.That( + async () => await processor.StartProcessingAsync(), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.StartProcessingStart( + processor.Identifier), + Times.Once); + mockLogger + .Verify( + log => log.StartProcessingException( + processor.Identifier, + It.IsAny()), + Times.Once); + } + + [Test] + public async Task StopProcessingExceptionLogsEvents() + { + var mockLogger = new Mock(); + var mockTransportReceiver = new Mock(); + var mockConnection = GetMockConnection(mockTransportReceiver); + mockTransportReceiver.Setup( + transportReceiver => transportReceiver.ReceiveBatchAsync( + 1, + It.IsAny(), + It.IsAny())) + .Returns(Task.FromResult((IList) + new List + { + new ServiceBusReceivedMessage + { + LockTokenGuid = Guid.NewGuid() + } + })); + var processor = new ServiceBusProcessor(mockConnection.Object, "queueName", false, new ServiceBusProcessorOptions + { + AutoComplete = false, + MaxAutoLockRenewalDuration = TimeSpan.Zero + }) + { + Logger = mockLogger.Object + }; + processor.ProcessErrorAsync += ExceptionHandler; + processor.ProcessMessageAsync += MessageHandler; + + async Task MessageHandler(ProcessMessageEventArgs arg) + { + // simulate IO + await Task.Delay(1000); + throw new TestException(); + } + + await processor.StartProcessingAsync(); + var cts = new CancellationTokenSource(); + cts.Cancel(); + Assert.That( + async () => await processor.StopProcessingAsync(cts.Token), + Throws.InstanceOf()); + + mockLogger + .Verify( + log => log.StopProcessingStart( + processor.Identifier), + Times.Once); + mockLogger + .Verify( + log => log.StopProcessingException( + processor.Identifier, + It.IsAny()), + Times.Once); + } + + private Mock GetMockConnection(Mock mockTransportReceiver) + { + var mockConnection = new Mock(); + mockConnection.Setup( + connection => connection.RetryOptions) + .Returns(new ServiceBusRetryOptions()); + mockConnection.Setup( + connection => connection.CreateTransportReceiver( + It.IsAny(), + It.IsAny(), + It.IsAny(), + It.IsAny(), + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns(mockTransportReceiver.Object); + return mockConnection; + } + + private Mock GetMockConnection(Mock mockTransportSender) + { + var mockConnection = new Mock(); + mockConnection.Setup( + connection => connection.RetryOptions) + .Returns(new ServiceBusRetryOptions()); + mockConnection.Setup( + connection => connection.CreateTransportSender( + It.IsAny(), + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns(mockTransportSender.Object); + return mockConnection; + } + } +} diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusLiveTestBase.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusLiveTestBase.cs index e92677ebc7ff..ecd79021b9c1 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusLiveTestBase.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusLiveTestBase.cs @@ -8,7 +8,7 @@ namespace Azure.Messaging.ServiceBus.Tests { [Category(TestCategory.Live)] [Category(TestCategory.DisallowVisualStudioLiveUnitTesting)] - public class ServiceBusLiveTestBase : ServiceBusTestBase + public abstract class ServiceBusLiveTestBase : ServiceBusTestBase { public ServiceBusTestEnvironment TestEnvironment { get; } = ServiceBusTestEnvironment.Instance; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs index 177fbb941803..06b371f5c2ca 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs @@ -4,16 +4,13 @@ using System; using System.Collections.Generic; using System.Security.Cryptography; -using System.Text; using System.Threading.Tasks; -using Azure.Core; -using Azure.Identity; using Moq; using NUnit.Framework; namespace Azure.Messaging.ServiceBus.Tests { - public class ServiceBusTestBase + public abstract class ServiceBusTestBase { protected IEnumerable GetMessages(int count, string sessionId = null, string partitionKey = null) { diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs index 902301f2c8e4..411f6b4c3681 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs @@ -186,7 +186,7 @@ public async Task SendBatchManagesLockingTheBatch() .Returns(new ServiceBusRetryOptions()); mockConnection - .Setup(connection => connection.CreateTransportSender(It.IsAny(), It.IsAny(), It.IsAny())) + .Setup(connection => connection.CreateTransportSender(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) .Returns(mockTransportSender.Object); mockConnection diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs index 8a7ecd44fcf9..224d0288fd89 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs @@ -157,102 +157,6 @@ public async Task TransactionalSendAndReceiveSubscription() }; } - //[Test] - //public async Task TransactionalRuleManagement() - //{ - // await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: false)) - // { - // var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); - - // ServiceBusSender sender = client.CreateSender(scope.TopicName); - - // var messageId1 = Guid.NewGuid().ToString(); - // var messageId2 = Guid.NewGuid().ToString(); - // var messageId3 = Guid.NewGuid().ToString(); - // await sender.SendAsync(new ServiceBusMessage { MessageId = messageId1, Label = "Blue" }); - - // ServiceBusReceiver receiver = client.CreateReceiver(scope.TopicName, scope.SubscriptionNames.First()); - // IList receivedMessages = await receiver.ReceiveBatchAsync(1); - - // ServiceBusRuleManager ruleManager = client.CreateRuleManager(scope.TopicName, scope.SubscriptionNames.First()); - // IEnumerable rulesDescription = await ruleManager.GetRulesAsync(); - // Assert.AreEqual(1, rulesDescription.Count()); - // Assert.AreEqual(RuleDescription.DefaultRuleName, rulesDescription.First().Name); - - // using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) - // { - // await ruleManager.RemoveRuleAsync(RuleDescription.DefaultRuleName); - // await ruleManager.AddRuleAsync(new RuleDescription - // { - // Filter = new CorrelationFilter { Label = "Red" }, - // Name = "CorrelationFilter" - // }); - - // await sender.SendAsync(new ServiceBusMessage { MessageId = messageId2, Label = "Red" }); - // await sender.SendAsync(new ServiceBusMessage { MessageId = messageId3, Label = "Green" }); - // await receiver.CompleteAsync(receivedMessages); - // ts.Complete(); - // } - - // rulesDescription = await ruleManager.GetRulesAsync(); - // Assert.AreEqual(1, rulesDescription.Count()); - // Assert.AreEqual("CorrelationFilter", rulesDescription.First().Name); - - // receivedMessages = await receiver.ReceiveBatchAsync(3); - // Assert.NotNull(receivedMessages); - // Assert.AreEqual(1, receivedMessages.Count()); - // Assert.AreEqual(messageId2, receivedMessages.First().MessageId); - // }; - //} - - //[Test] - //public async Task TransactionalRuleManagementRollback() - //{ - // await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: false)) - // { - // var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); - - // ServiceBusSender sender = client.CreateSender(scope.TopicName); - - // var messageId1 = Guid.NewGuid().ToString(); - // var messageId2 = Guid.NewGuid().ToString(); - // var messageId3 = Guid.NewGuid().ToString(); - // await sender.SendAsync(new ServiceBusMessage { MessageId = messageId1, Label = "Blue" }); - - // ServiceBusReceiver receiver = client.CreateReceiver(scope.TopicName, scope.SubscriptionNames.First()); - // IList receivedMessages = await receiver.ReceiveBatchAsync(1); - - // ServiceBusRuleManager ruleManager = client.CreateRuleManager(scope.TopicName, scope.SubscriptionNames.First()); - // IEnumerable rulesDescription = await ruleManager.GetRulesAsync(); - // Assert.AreEqual(1, rulesDescription.Count()); - // Assert.AreEqual(RuleDescription.DefaultRuleName, rulesDescription.First().Name); - - // using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) - // { - // await ruleManager.RemoveRuleAsync(RuleDescription.DefaultRuleName); - // await ruleManager.AddRuleAsync(new RuleDescription - // { - // Filter = new CorrelationFilter { Label = "Red" }, - // Name = "CorrelationFilter" - // }); - - // await sender.SendAsync(new ServiceBusMessage { MessageId = messageId2, Label = "Red" }); - // await sender.SendAsync(new ServiceBusMessage { MessageId = messageId3, Label = "Green" }); - // await receiver.CompleteAsync(receivedMessages); - // // not completing the transaction - // } - - // rulesDescription = await ruleManager.GetRulesAsync(); - // Assert.AreEqual(1, rulesDescription.Count()); - // Assert.AreEqual(RuleDescription.DefaultRuleName, rulesDescription.First().Name); - - // receivedMessages = await receiver.ReceiveBatchAsync(3); - // Assert.NotNull(receivedMessages); - // Assert.AreEqual(1, receivedMessages.Count()); - // Assert.AreEqual(messageId1, receivedMessages.First().MessageId); - // }; - //} - [Test] [TestCase(false, false)] [TestCase(false, true)]