add eventhub name into load balancer logs (Azure#47271)

tovyhnal · web-flow · commit f0a9a8de5833 · 2024-11-21T16:58:02.000-08:00
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Diagnostics/PartitionLoadBalancerEventSource.cs b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Diagnostics/PartitionLoadBalancerEventSource.cs
@@ -43,13 +43,14 @@ protected PartitionLoadBalancerEventSource() : base(EventSourceName)
         /// </summary>
         ///
         /// <param name="count"> Minimum partitions per event processor.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(1, Level = EventLevel.Verbose, Message = "Expected minimum partitions per event processor '{0}'.")]
-        public virtual void MinimumPartitionsPerEventProcessor(int count)
+        [Event(1, Level = EventLevel.Verbose, Message = "Expected minimum partitions per event processor '{0}' for Event Hub '{1}'.")]
+        public virtual void MinimumPartitionsPerEventProcessor(int count, string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(1, count);
+                WriteEvent(1, count, eventHubName);
             }
         }
 
@@ -59,14 +60,16 @@ public virtual void MinimumPartitionsPerEventProcessor(int count)
         ///
         /// <param name="identifier">A unique name used to identify the associated event processor.</param>
         /// <param name="count"> Current ownership count.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(2, Level = EventLevel.Informational, Message = "Current ownership count is {0}. (Identifier: '{1}')")]
+        [Event(2, Level = EventLevel.Informational, Message = "Current ownership count is {0} for Event Hub '{2}'. (Identifier: '{1}')")]
         public virtual void CurrentOwnershipCount(int count,
-                                                  string identifier)
+                                                  string identifier,
+                                                  string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(2, count, identifier ?? string.Empty);
+                WriteEvent(2, count, identifier ?? string.Empty, eventHubName);
             }
         }
 
@@ -75,13 +78,14 @@ public virtual void CurrentOwnershipCount(int count,
         /// </summary>
         ///
         /// <param name="unclaimedPartitions">List of unclaimed partitions.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(3, Level = EventLevel.Informational, Message = "Unclaimed partitions: '{0}'.")]
-        public virtual void UnclaimedPartitions(HashSet<string> unclaimedPartitions)
+        [Event(3, Level = EventLevel.Informational, Message = "Unclaimed partitions: '{0}' for Event Hub '{1}'.")]
+        public virtual void UnclaimedPartitions(HashSet<string> unclaimedPartitions, string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(3, string.Join(", ", unclaimedPartitions));
+                WriteEvent(3, string.Join(", ", unclaimedPartitions), eventHubName);
             }
         }
 
@@ -90,13 +94,14 @@ public virtual void UnclaimedPartitions(HashSet<string> unclaimedPartitions)
         /// </summary>
         ///
         /// <param name="partitionId">The identifier of the Event Hub partition whose ownership claim attempt is starting.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(4, Level = EventLevel.Informational, Message = "Attempting to claim ownership of partition '{0}'.")]
-        public virtual void ClaimOwnershipStart(string partitionId)
+        [Event(4, Level = EventLevel.Informational, Message = "Attempting to claim ownership of partition '{0}' for Event Hub '{1}'.")]
+        public virtual void ClaimOwnershipStart(string partitionId, string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(4, partitionId ?? string.Empty);
+                WriteEvent(4, partitionId ?? string.Empty, eventHubName);
             }
         }
 
@@ -106,14 +111,16 @@ public virtual void ClaimOwnershipStart(string partitionId)
         ///
         /// <param name="partitionId">The identifier of the Event Hub partition.</param>
         /// <param name="errorMessage">The message for the exception that occurred.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(5, Level = EventLevel.Error, Message = "Failed to claim ownership of partition '{0}'. (ErrorMessage: '{1}')")]
+        [Event(5, Level = EventLevel.Error, Message = "Failed to claim ownership of partition '{0}' for Event Hub '{2}'. (ErrorMessage: '{1}')")]
         public virtual void ClaimOwnershipError(string partitionId,
-                                                string errorMessage)
+                                                string errorMessage,
+                                                string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(5, partitionId ?? string.Empty, errorMessage ?? string.Empty);
+                WriteEvent(5, partitionId ?? string.Empty, errorMessage ?? string.Empty, eventHubName);
             }
         }
 
@@ -122,13 +129,14 @@ public virtual void ClaimOwnershipError(string partitionId,
         /// </summary>
         ///
         /// <param name="identifier">A unique name used to identify the associated event processor.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(6, Level = EventLevel.Informational, Message = "Load is unbalanced and this load balancer should steal a partition. (Identifier: '{0}')")]
-        public virtual void ShouldStealPartition(string identifier)
+        [Event(6, Level = EventLevel.Informational, Message = "Load is unbalanced and this load balancer should steal a partition for Event Hub '{1}'. (Identifier: '{0}')")]
+        public virtual void ShouldStealPartition(string identifier, string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(6, identifier ?? string.Empty);
+                WriteEvent(6, identifier ?? string.Empty, eventHubName);
             }
         }
 
@@ -139,15 +147,17 @@ public virtual void ShouldStealPartition(string identifier)
         /// <param name="partitionId">The identifier of the partition that was selected to be stolen.</param>
         /// <param name="stolenFrom">The identifier of the event processor that is being stolen from.</param>
         /// <param name="identifier">A unique name used to identify the associated event processor.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(7, Level = EventLevel.Informational, Message = "No unclaimed partitions, attempting to steal partition '{0}' from event processor '{1}'. (Identifier: '{2}')")]
+        [Event(7, Level = EventLevel.Informational, Message = "No unclaimed partitions, attempting to steal partition '{0}' from event processor '{1}' for Event Hub '{3}'. (Identifier: '{2}').")]
         public virtual void StealPartition(string partitionId,
                                            string stolenFrom,
-                                           string identifier)
+                                           string identifier,
+                                           string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(7, partitionId ?? string.Empty, stolenFrom ?? string.Empty, identifier ?? string.Empty);
+                WriteEvent(7, partitionId ?? string.Empty, stolenFrom ?? string.Empty, identifier ?? string.Empty, eventHubName);
             }
         }
 
@@ -156,13 +166,14 @@ public virtual void StealPartition(string partitionId,
         /// </summary>
         ///
         /// <param name="identifier">A unique name used to identify the associated event processor.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(8, Level = EventLevel.Verbose, Message = "Attempting to renew ownership. (Identifier: '{0}')")]
-        public virtual void RenewOwnershipStart(string identifier)
+        [Event(8, Level = EventLevel.Verbose, Message = "Attempting to renew ownership for Event Hub '{1}'. (Identifier: '{0}')")]
+        public virtual void RenewOwnershipStart(string identifier, string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(8, identifier ?? string.Empty);
+                WriteEvent(8, identifier ?? string.Empty, eventHubName);
             }
         }
 
@@ -172,14 +183,16 @@ public virtual void RenewOwnershipStart(string identifier)
         ///
         /// <param name="identifier">A unique name used to identify the associated event processor.</param>
         /// <param name="errorMessage">The message for the exception that occurred.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(9, Level = EventLevel.Error, Message = "Failed to renew ownership. (Identifier: '{0}'; ErrorMessage: '{0}')")]
+        [Event(9, Level = EventLevel.Error, Message = "Failed to renew ownership for Event Hub '{2}'. (Identifier: '{0}'; ErrorMessage: '{1}')")]
         public virtual void RenewOwnershipError(string identifier,
-                                                string errorMessage)
+                                                string errorMessage,
+                                                string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(9, identifier ?? string.Empty, errorMessage ?? string.Empty);
+                WriteEvent(9, identifier ?? string.Empty, errorMessage ?? string.Empty, eventHubName);
             }
         }
 
@@ -188,13 +201,14 @@ public virtual void RenewOwnershipError(string identifier,
         /// </summary>
         ///
         /// <param name="identifier">A unique name used to identify the associated event processor.</param>
+        /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>
         ///
-        [Event(10, Level = EventLevel.Verbose, Message = "Attempt to renew ownership has completed. (Identifier: '{0}')")]
-        public virtual void RenewOwnershipComplete(string identifier)
+        [Event(10, Level = EventLevel.Verbose, Message = "Attempt to renew ownership has completed for Event Hub '{1}'. (Identifier: '{0}')")]
+        public virtual void RenewOwnershipComplete(string identifier, string eventHubName)
         {
             if (IsEnabled())
             {
-                WriteEvent(10, identifier ?? string.Empty);
+                WriteEvent(10, identifier ?? string.Empty, eventHubName);
             }
         }
     }
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Processor/PartitionLoadBalancer.cs b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/src/Processor/PartitionLoadBalancer.cs
@@ -350,10 +350,10 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio
 
             var unevenPartitionDistribution = (partitionCount % ActiveOwnershipWithDistribution.Keys.Count) > 0;
             var minimumOwnedPartitionsCount = partitionCount / ActiveOwnershipWithDistribution.Keys.Count;
-            Logger.MinimumPartitionsPerEventProcessor(minimumOwnedPartitionsCount);
+            Logger.MinimumPartitionsPerEventProcessor(minimumOwnedPartitionsCount, EventHubName);
 
             var ownedPartitionsCount = ActiveOwnershipWithDistribution[OwnerIdentifier].Count;
-            Logger.CurrentOwnershipCount(ownedPartitionsCount, OwnerIdentifier);
+            Logger.CurrentOwnershipCount(ownedPartitionsCount, OwnerIdentifier, EventHubName);
 
             // There are two possible situations in which we may need to claim a partition ownership:
             //
@@ -374,7 +374,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio
             {
                 // Look for unclaimed partitions.  If any, randomly pick one of them to claim.
 
-                Logger.UnclaimedPartitions(unclaimedPartitions);
+                Logger.UnclaimedPartitions(unclaimedPartitions, EventHubName);
 
                 if (unclaimedPartitions.Count > 0)
                 {
@@ -423,7 +423,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio
                 if ((ownedPartitionsCount < minimumOwnedPartitionsCount)
                     || (ownedPartitionsCount < maximumOwnedPartitionsCount && partitionsOwnedByProcessorWithGreaterThanMaximumOwnedPartitionsCount.Count > 0))
                 {
-                    Logger.ShouldStealPartition(OwnerIdentifier);
+                    Logger.ShouldStealPartition(OwnerIdentifier, EventHubName);
 
                     // Prefer stealing from a processor that owns more than the maximum number of partitions.
 
@@ -444,7 +444,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio
                             }
                         }
 
-                        Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier);
+                        Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier, EventHubName);
 
                         var returnTask = ClaimOwnershipAsync(
                             partitionToSteal,
@@ -474,7 +474,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio
                             }
                         }
 
-                        Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier);
+                        Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier, EventHubName);
 
                         var returnTask = ClaimOwnershipAsync(
                             partitionToSteal,
@@ -501,7 +501,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();
 
-            Logger.RenewOwnershipStart(OwnerIdentifier);
+            Logger.RenewOwnershipStart(OwnerIdentifier, EventHubName);
 
             var utcNow = GetDateTimeOffsetNow();
 
@@ -543,7 +543,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)
                 // If ownership renewal fails just give up and try again in the next cycle.  The processor may
                 // end up losing some of its ownership.
 
-                Logger.RenewOwnershipError(OwnerIdentifier, ex.Message);
+                Logger.RenewOwnershipError(OwnerIdentifier, ex.Message, EventHubName);
 
                 // Set the EventHubName to null so it doesn't modify the exception message. This exception message is
                 // used so the processor can retrieve the raw Operation string, and adding the EventHubName would append
@@ -553,7 +553,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)
             }
             finally
             {
-                Logger.RenewOwnershipComplete(OwnerIdentifier);
+                Logger.RenewOwnershipComplete(OwnerIdentifier, EventHubName);
             }
         }
 
@@ -572,7 +572,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)
                                                                                                                             CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();
-            Logger.ClaimOwnershipStart(partitionId);
+            Logger.ClaimOwnershipStart(partitionId, EventHubName);
 
             // We need the eTag from the most recent ownership of this partition, even if it's expired.  We want to keep the offset and
             // the sequence number as well.
@@ -602,7 +602,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)
 
                 // If ownership claim fails, just treat it as a usual ownership claim failure.
 
-                Logger.ClaimOwnershipError(partitionId, ex.Message);
+                Logger.ClaimOwnershipError(partitionId, ex.Message, EventHubName);
 
                 // Set the EventHubName to null so it doesn't modify the exception message. This exception message is
                 // used so the processor can retrieve the raw Operation string, and adding the EventHubName would append
diff --git a/sdk/eventhub/Azure.Messaging.EventHubs.Shared/tests/Processor/PartitionLoadBalancerTests.cs b/sdk/eventhub/Azure.Messaging.EventHubs.Shared/tests/Processor/PartitionLoadBalancerTests.cs
@@ -540,7 +540,7 @@ public async Task RunLoadBalancingAsyncDoesNotStealFromItself()
 
             // Verify that no attempts to steal were logged.
 
-            mockLog.Verify(log => log.ShouldStealPartition(It.IsAny<string>()), Times.Never);
+            mockLog.Verify(log => log.ShouldStealPartition(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
 
         /// <summary>
@@ -597,7 +597,7 @@ public async Task RunLoadBalancingAsyncDoesNotStealWhenLessPartitionsThanProcess
 
             // Verify that no attempts to steal were logged.
 
-            mockLog.Verify(log => log.ShouldStealPartition(It.IsAny<string>()), Times.Never);
+            mockLog.Verify(log => log.ShouldStealPartition(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
 
         /// <summary>
@@ -678,7 +678,7 @@ public async Task RunLoadBalancingAsyncDoesNotStealWhenTheLoadIsBalanced(int[] a
 
             // Verify that no attempts to steal were logged.
 
-            mockLog.Verify(log => log.ShouldStealPartition(It.IsAny<string>()), Times.Never);
+            mockLog.Verify(log => log.ShouldStealPartition(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
         }
 
         /// <summary>
@@ -902,14 +902,14 @@ public async Task VerifiesEventProcessorLogs()
 
             await loadbalancer.RelinquishOwnershipAsync(CancellationToken.None);
 
-            mockLog.Verify(m => m.RenewOwnershipStart(loadbalancer.OwnerIdentifier));
-            mockLog.Verify(m => m.RenewOwnershipComplete(loadbalancer.OwnerIdentifier));
-            mockLog.Verify(m => m.ClaimOwnershipStart(It.Is<string>(p => partitionIds.Contains(p))));
-            mockLog.Verify(m => m.MinimumPartitionsPerEventProcessor(MinimumpartitionCount));
-            mockLog.Verify(m => m.CurrentOwnershipCount(MinimumpartitionCount, loadbalancer.OwnerIdentifier));
-            mockLog.Verify(m => m.StealPartition(It.IsAny<string>(), It.IsAny<string>(), loadbalancer.OwnerIdentifier));
-            mockLog.Verify(m => m.ShouldStealPartition(loadbalancer.OwnerIdentifier));
-            mockLog.Verify(m => m.UnclaimedPartitions(It.Is<HashSet<string>>(set => set.Count == 0 || set.All(item => partitionIds.Contains(item)))));
+            mockLog.Verify(m => m.RenewOwnershipStart(loadbalancer.OwnerIdentifier, loadbalancer.EventHubName));
+            mockLog.Verify(m => m.RenewOwnershipComplete(loadbalancer.OwnerIdentifier, loadbalancer.EventHubName));
+            mockLog.Verify(m => m.ClaimOwnershipStart(It.Is<string>(p => partitionIds.Contains(p)), loadbalancer.EventHubName));
+            mockLog.Verify(m => m.MinimumPartitionsPerEventProcessor(MinimumpartitionCount, loadbalancer.EventHubName));
+            mockLog.Verify(m => m.CurrentOwnershipCount(MinimumpartitionCount, loadbalancer.OwnerIdentifier, loadbalancer.EventHubName));
+            mockLog.Verify(m => m.StealPartition(It.IsAny<string>(), It.IsAny<string>(), loadbalancer.OwnerIdentifier, loadbalancer.EventHubName));
+            mockLog.Verify(m => m.ShouldStealPartition(loadbalancer.OwnerIdentifier, loadbalancer.EventHubName));
+            mockLog.Verify(m => m.UnclaimedPartitions(It.Is<HashSet<string>>(set => set.Count == 0 || set.All(item => partitionIds.Contains(item))), loadbalancer.EventHubName));
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -43,13 +43,14 @@ protected PartitionLoadBalancerEventSource() : base(EventSourceName)`
`43`	`43`	`/// </summary>`
`44`	`44`	`///`
`45`	`45`	`/// <param name="count"> Minimum partitions per event processor.</param>`
	`46`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`46`	`47`	`///`
`47`		`- [Event(1, Level = EventLevel.Verbose, Message = "Expected minimum partitions per event processor '{0}'.")]`
`48`		`- public virtual void MinimumPartitionsPerEventProcessor(int count)`
	`48`	`+ [Event(1, Level = EventLevel.Verbose, Message = "Expected minimum partitions per event processor '{0}' for Event Hub '{1}'.")]`
	`49`	`+ public virtual void MinimumPartitionsPerEventProcessor(int count, string eventHubName)`
`49`	`50`	`{`
`50`	`51`	`if (IsEnabled())`
`51`	`52`	`{`
`52`		`- WriteEvent(1, count);`
	`53`	`+ WriteEvent(1, count, eventHubName);`
`53`	`54`	`}`
`54`	`55`	`}`
`55`	`56`
`@@ -59,14 +60,16 @@ public virtual void MinimumPartitionsPerEventProcessor(int count)`
`59`	`60`	`///`
`60`	`61`	`/// <param name="identifier">A unique name used to identify the associated event processor.</param>`
`61`	`62`	`/// <param name="count"> Current ownership count.</param>`
	`63`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`62`	`64`	`///`
`63`		`- [Event(2, Level = EventLevel.Informational, Message = "Current ownership count is {0}. (Identifier: '{1}')")]`
	`65`	`+ [Event(2, Level = EventLevel.Informational, Message = "Current ownership count is {0} for Event Hub '{2}'. (Identifier: '{1}')")]`
`64`	`66`	`public virtual void CurrentOwnershipCount(int count,`
`65`		`- string identifier)`
	`67`	`+ string identifier,`
	`68`	`+ string eventHubName)`
`66`	`69`	`{`
`67`	`70`	`if (IsEnabled())`
`68`	`71`	`{`
`69`		`- WriteEvent(2, count, identifier ?? string.Empty);`
	`72`	`+ WriteEvent(2, count, identifier ?? string.Empty, eventHubName);`
`70`	`73`	`}`
`71`	`74`	`}`
`72`	`75`
`@@ -75,13 +78,14 @@ public virtual void CurrentOwnershipCount(int count,`
`75`	`78`	`/// </summary>`
`76`	`79`	`///`
`77`	`80`	`/// <param name="unclaimedPartitions">List of unclaimed partitions.</param>`
	`81`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`78`	`82`	`///`
`79`		`- [Event(3, Level = EventLevel.Informational, Message = "Unclaimed partitions: '{0}'.")]`
`80`		`- public virtual void UnclaimedPartitions(HashSet<string> unclaimedPartitions)`
	`83`	`+ [Event(3, Level = EventLevel.Informational, Message = "Unclaimed partitions: '{0}' for Event Hub '{1}'.")]`
	`84`	`+ public virtual void UnclaimedPartitions(HashSet<string> unclaimedPartitions, string eventHubName)`
`81`	`85`	`{`
`82`	`86`	`if (IsEnabled())`
`83`	`87`	`{`
`84`		`- WriteEvent(3, string.Join(", ", unclaimedPartitions));`
	`88`	`+ WriteEvent(3, string.Join(", ", unclaimedPartitions), eventHubName);`
`85`	`89`	`}`
`86`	`90`	`}`
`87`	`91`
`@@ -90,13 +94,14 @@ public virtual void UnclaimedPartitions(HashSet<string> unclaimedPartitions)`
`90`	`94`	`/// </summary>`
`91`	`95`	`///`
`92`	`96`	`/// <param name="partitionId">The identifier of the Event Hub partition whose ownership claim attempt is starting.</param>`
	`97`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`93`	`98`	`///`
`94`		`- [Event(4, Level = EventLevel.Informational, Message = "Attempting to claim ownership of partition '{0}'.")]`
`95`		`- public virtual void ClaimOwnershipStart(string partitionId)`
	`99`	`+ [Event(4, Level = EventLevel.Informational, Message = "Attempting to claim ownership of partition '{0}' for Event Hub '{1}'.")]`
	`100`	`+ public virtual void ClaimOwnershipStart(string partitionId, string eventHubName)`
`96`	`101`	`{`
`97`	`102`	`if (IsEnabled())`
`98`	`103`	`{`
`99`		`- WriteEvent(4, partitionId ?? string.Empty);`
	`104`	`+ WriteEvent(4, partitionId ?? string.Empty, eventHubName);`
`100`	`105`	`}`
`101`	`106`	`}`
`102`	`107`
`@@ -106,14 +111,16 @@ public virtual void ClaimOwnershipStart(string partitionId)`
`106`	`111`	`///`
`107`	`112`	`/// <param name="partitionId">The identifier of the Event Hub partition.</param>`
`108`	`113`	`/// <param name="errorMessage">The message for the exception that occurred.</param>`
	`114`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`109`	`115`	`///`
`110`		`- [Event(5, Level = EventLevel.Error, Message = "Failed to claim ownership of partition '{0}'. (ErrorMessage: '{1}')")]`
	`116`	`+ [Event(5, Level = EventLevel.Error, Message = "Failed to claim ownership of partition '{0}' for Event Hub '{2}'. (ErrorMessage: '{1}')")]`
`111`	`117`	`public virtual void ClaimOwnershipError(string partitionId,`
`112`		`- string errorMessage)`
	`118`	`+ string errorMessage,`
	`119`	`+ string eventHubName)`
`113`	`120`	`{`
`114`	`121`	`if (IsEnabled())`
`115`	`122`	`{`
`116`		`- WriteEvent(5, partitionId ?? string.Empty, errorMessage ?? string.Empty);`
	`123`	`+ WriteEvent(5, partitionId ?? string.Empty, errorMessage ?? string.Empty, eventHubName);`
`117`	`124`	`}`
`118`	`125`	`}`
`119`	`126`
`@@ -122,13 +129,14 @@ public virtual void ClaimOwnershipError(string partitionId,`
`122`	`129`	`/// </summary>`
`123`	`130`	`///`
`124`	`131`	`/// <param name="identifier">A unique name used to identify the associated event processor.</param>`
	`132`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`125`	`133`	`///`
`126`		`- [Event(6, Level = EventLevel.Informational, Message = "Load is unbalanced and this load balancer should steal a partition. (Identifier: '{0}')")]`
`127`		`- public virtual void ShouldStealPartition(string identifier)`
	`134`	`+ [Event(6, Level = EventLevel.Informational, Message = "Load is unbalanced and this load balancer should steal a partition for Event Hub '{1}'. (Identifier: '{0}')")]`
	`135`	`+ public virtual void ShouldStealPartition(string identifier, string eventHubName)`
`128`	`136`	`{`
`129`	`137`	`if (IsEnabled())`
`130`	`138`	`{`
`131`		`- WriteEvent(6, identifier ?? string.Empty);`
	`139`	`+ WriteEvent(6, identifier ?? string.Empty, eventHubName);`
`132`	`140`	`}`
`133`	`141`	`}`
`134`	`142`
`@@ -139,15 +147,17 @@ public virtual void ShouldStealPartition(string identifier)`
`139`	`147`	`/// <param name="partitionId">The identifier of the partition that was selected to be stolen.</param>`
`140`	`148`	`/// <param name="stolenFrom">The identifier of the event processor that is being stolen from.</param>`
`141`	`149`	`/// <param name="identifier">A unique name used to identify the associated event processor.</param>`
	`150`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`142`	`151`	`///`
`143`		`- [Event(7, Level = EventLevel.Informational, Message = "No unclaimed partitions, attempting to steal partition '{0}' from event processor '{1}'. (Identifier: '{2}')")]`
	`152`	`+ [Event(7, Level = EventLevel.Informational, Message = "No unclaimed partitions, attempting to steal partition '{0}' from event processor '{1}' for Event Hub '{3}'. (Identifier: '{2}').")]`
`144`	`153`	`public virtual void StealPartition(string partitionId,`
`145`	`154`	`string stolenFrom,`
`146`		`- string identifier)`
	`155`	`+ string identifier,`
	`156`	`+ string eventHubName)`
`147`	`157`	`{`
`148`	`158`	`if (IsEnabled())`
`149`	`159`	`{`
`150`		`- WriteEvent(7, partitionId ?? string.Empty, stolenFrom ?? string.Empty, identifier ?? string.Empty);`
	`160`	`+ WriteEvent(7, partitionId ?? string.Empty, stolenFrom ?? string.Empty, identifier ?? string.Empty, eventHubName);`
`151`	`161`	`}`
`152`	`162`	`}`
`153`	`163`
`@@ -156,13 +166,14 @@ public virtual void StealPartition(string partitionId,`
`156`	`166`	`/// </summary>`
`157`	`167`	`///`
`158`	`168`	`/// <param name="identifier">A unique name used to identify the associated event processor.</param>`
	`169`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`159`	`170`	`///`
`160`		`- [Event(8, Level = EventLevel.Verbose, Message = "Attempting to renew ownership. (Identifier: '{0}')")]`
`161`		`- public virtual void RenewOwnershipStart(string identifier)`
	`171`	`+ [Event(8, Level = EventLevel.Verbose, Message = "Attempting to renew ownership for Event Hub '{1}'. (Identifier: '{0}')")]`
	`172`	`+ public virtual void RenewOwnershipStart(string identifier, string eventHubName)`
`162`	`173`	`{`
`163`	`174`	`if (IsEnabled())`
`164`	`175`	`{`
`165`		`- WriteEvent(8, identifier ?? string.Empty);`
	`176`	`+ WriteEvent(8, identifier ?? string.Empty, eventHubName);`
`166`	`177`	`}`
`167`	`178`	`}`
`168`	`179`
`@@ -172,14 +183,16 @@ public virtual void RenewOwnershipStart(string identifier)`
`172`	`183`	`///`
`173`	`184`	`/// <param name="identifier">A unique name used to identify the associated event processor.</param>`
`174`	`185`	`/// <param name="errorMessage">The message for the exception that occurred.</param>`
	`186`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`175`	`187`	`///`
`176`		`- [Event(9, Level = EventLevel.Error, Message = "Failed to renew ownership. (Identifier: '{0}'; ErrorMessage: '{0}')")]`
	`188`	`+ [Event(9, Level = EventLevel.Error, Message = "Failed to renew ownership for Event Hub '{2}'. (Identifier: '{0}'; ErrorMessage: '{1}')")]`
`177`	`189`	`public virtual void RenewOwnershipError(string identifier,`
`178`		`- string errorMessage)`
	`190`	`+ string errorMessage,`
	`191`	`+ string eventHubName)`
`179`	`192`	`{`
`180`	`193`	`if (IsEnabled())`
`181`	`194`	`{`
`182`		`- WriteEvent(9, identifier ?? string.Empty, errorMessage ?? string.Empty);`
	`195`	`+ WriteEvent(9, identifier ?? string.Empty, errorMessage ?? string.Empty, eventHubName);`
`183`	`196`	`}`
`184`	`197`	`}`
`185`	`198`
`@@ -188,13 +201,14 @@ public virtual void RenewOwnershipError(string identifier,`
`188`	`201`	`/// </summary>`
`189`	`202`	`///`
`190`	`203`	`/// <param name="identifier">A unique name used to identify the associated event processor.</param>`
	`204`	`+ /// <param name="eventHubName">The name of the Event Hub that the load balancer is associated with.</param>`
`191`	`205`	`///`
`192`		`- [Event(10, Level = EventLevel.Verbose, Message = "Attempt to renew ownership has completed. (Identifier: '{0}')")]`
`193`		`- public virtual void RenewOwnershipComplete(string identifier)`
	`206`	`+ [Event(10, Level = EventLevel.Verbose, Message = "Attempt to renew ownership has completed for Event Hub '{1}'. (Identifier: '{0}')")]`
	`207`	`+ public virtual void RenewOwnershipComplete(string identifier, string eventHubName)`
`194`	`208`	`{`
`195`	`209`	`if (IsEnabled())`
`196`	`210`	`{`
`197`		`- WriteEvent(10, identifier ?? string.Empty);`
	`211`	`+ WriteEvent(10, identifier ?? string.Empty, eventHubName);`
`198`	`212`	`}`
`199`	`213`	`}`
`200`	`214`	`}`
Original file line number	Diff line number	Diff line change
`@@ -350,10 +350,10 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio`
`350`	`350`
`351`	`351`	`var unevenPartitionDistribution = (partitionCount % ActiveOwnershipWithDistribution.Keys.Count) > 0;`
`352`	`352`	`var minimumOwnedPartitionsCount = partitionCount / ActiveOwnershipWithDistribution.Keys.Count;`
`353`		`- Logger.MinimumPartitionsPerEventProcessor(minimumOwnedPartitionsCount);`
	`353`	`+ Logger.MinimumPartitionsPerEventProcessor(minimumOwnedPartitionsCount, EventHubName);`
`354`	`354`
`355`	`355`	`var ownedPartitionsCount = ActiveOwnershipWithDistribution[OwnerIdentifier].Count;`
`356`		`- Logger.CurrentOwnershipCount(ownedPartitionsCount, OwnerIdentifier);`
	`356`	`+ Logger.CurrentOwnershipCount(ownedPartitionsCount, OwnerIdentifier, EventHubName);`
`357`	`357`
`358`	`358`	`// There are two possible situations in which we may need to claim a partition ownership:`
`359`	`359`	`//`
`@@ -374,7 +374,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio`
`374`	`374`	`{`
`375`	`375`	`// Look for unclaimed partitions. If any, randomly pick one of them to claim.`
`376`	`376`
`377`		`- Logger.UnclaimedPartitions(unclaimedPartitions);`
	`377`	`+ Logger.UnclaimedPartitions(unclaimedPartitions, EventHubName);`
`378`	`378`
`379`	`379`	`if (unclaimedPartitions.Count > 0)`
`380`	`380`	`{`
`@@ -423,7 +423,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio`
`423`	`423`	`if ((ownedPartitionsCount < minimumOwnedPartitionsCount)`
`424`	`424`	`\|\| (ownedPartitionsCount < maximumOwnedPartitionsCount && partitionsOwnedByProcessorWithGreaterThanMaximumOwnedPartitionsCount.Count > 0))`
`425`	`425`	`{`
`426`		`- Logger.ShouldStealPartition(OwnerIdentifier);`
	`426`	`+ Logger.ShouldStealPartition(OwnerIdentifier, EventHubName);`
`427`	`427`
`428`	`428`	`// Prefer stealing from a processor that owns more than the maximum number of partitions.`
`429`	`429`
`@@ -444,7 +444,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio`
`444`	`444`	`}`
`445`	`445`	`}`
`446`	`446`
`447`		`- Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier);`
	`447`	`+ Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier, EventHubName);`
`448`	`448`
`449`	`449`	`var returnTask = ClaimOwnershipAsync(`
`450`	`450`	`partitionToSteal,`
`@@ -474,7 +474,7 @@ public virtual async Task RelinquishOwnershipAsync(CancellationToken cancellatio`
`474`	`474`	`}`
`475`	`475`	`}`
`476`	`476`
`477`		`- Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier);`
	`477`	`+ Logger.StealPartition(partitionToSteal, stealingFrom, OwnerIdentifier, EventHubName);`
`478`	`478`
`479`	`479`	`var returnTask = ClaimOwnershipAsync(`
`480`	`480`	`partitionToSteal,`
`@@ -501,7 +501,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)`
`501`	`501`	`{`
`502`	`502`	`cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();`
`503`	`503`
`504`		`- Logger.RenewOwnershipStart(OwnerIdentifier);`
	`504`	`+ Logger.RenewOwnershipStart(OwnerIdentifier, EventHubName);`
`505`	`505`
`506`	`506`	`var utcNow = GetDateTimeOffsetNow();`
`507`	`507`
`@@ -543,7 +543,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)`
`543`	`543`	`// If ownership renewal fails just give up and try again in the next cycle. The processor may`
`544`	`544`	`// end up losing some of its ownership.`
`545`	`545`
`546`		`- Logger.RenewOwnershipError(OwnerIdentifier, ex.Message);`
	`546`	`+ Logger.RenewOwnershipError(OwnerIdentifier, ex.Message, EventHubName);`
`547`	`547`
`548`	`548`	`// Set the EventHubName to null so it doesn't modify the exception message. This exception message is`
`549`	`549`	`// used so the processor can retrieve the raw Operation string, and adding the EventHubName would append`
`@@ -553,7 +553,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)`
`553`	`553`	`}`
`554`	`554`	`finally`
`555`	`555`	`{`
`556`		`- Logger.RenewOwnershipComplete(OwnerIdentifier);`
	`556`	`+ Logger.RenewOwnershipComplete(OwnerIdentifier, EventHubName);`
`557`	`557`	`}`
`558`	`558`	`}`
`559`	`559`
`@@ -572,7 +572,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)`
`572`	`572`	`CancellationToken cancellationToken)`
`573`	`573`	`{`
`574`	`574`	`cancellationToken.ThrowIfCancellationRequested<TaskCanceledException>();`
`575`		`- Logger.ClaimOwnershipStart(partitionId);`
	`575`	`+ Logger.ClaimOwnershipStart(partitionId, EventHubName);`
`576`	`576`
`577`	`577`	`// We need the eTag from the most recent ownership of this partition, even if it's expired. We want to keep the offset and`
`578`	`578`	`// the sequence number as well.`
`@@ -602,7 +602,7 @@ private async Task RenewOwnershipAsync(CancellationToken cancellationToken)`
`602`	`602`
`603`	`603`	`// If ownership claim fails, just treat it as a usual ownership claim failure.`
`604`	`604`
`605`		`- Logger.ClaimOwnershipError(partitionId, ex.Message);`
	`605`	`+ Logger.ClaimOwnershipError(partitionId, ex.Message, EventHubName);`
`606`	`606`
`607`	`607`	`// Set the EventHubName to null so it doesn't modify the exception message. This exception message is`
`608`	`608`	`// used so the processor can retrieve the raw Operation string, and adding the EventHubName would append`