Merge pull request #266477 from spelluru/ehubfreshness0215

Event Hubs freshness review

Author: American-Dipper

articles/event-hubs/.openpublishing.redirection.event-hubs.json

@@ -1,5 +1,10 @@
 {
   "redirections": [
+  {
+      "source_path": "event-hubs-event-processor-host.md",
+      "redirect_url": "/azure/event-hubs/event-processor-balance-partition-load",
+      "redirect_document_id": false
+  },
   {
     "source_path": "use-blob-storage-checkpoint-store-azure-stack-hub.md",
     "redirect_url": "/azure/event-hubs/troubleshoot-checkpoint-store-issues",

articles/event-hubs/TOC.yml

@@ -123,11 +123,9 @@
         href: schema-registry-concepts.md   
       - name: Client-side schema enforcement
         href: schema-registry-client-side-enforcement.md
-    - name: Event processing using SDKs
+    - name: Event processing
       items: 
-      - name: Event processor host (legacy SDK)
-        href: event-hubs-event-processor-host.md
-      - name: Event processor (latest SDK)
+      - name: Event processor
         href: event-processor-balance-partition-load.md
       - name: Event processing with no code editor
         href: ../stream-analytics/no-code-stream-processing.md?toc=/azure/event-hubs/toc.json

articles/event-hubs/dynamically-add-partitions.md

@@ -69,7 +69,7 @@ Event Hubs provides three sender options:
 - **Round-robin sender (default)** – In this scenario, the Event Hubs service round robins the events across partitions, and also uses a load-balancing algorithm. Event Hubs service is aware of partition count changes and will send to new partitions within seconds of altering partition count.
 
 ### Receiver/consumer clients
-Event Hubs provides direct receivers and an easy consumer library called the [Event Processor Host (old SDK)](event-hubs-event-processor-host.md)  or [Event Processor (new SDK)](event-processor-balance-partition-load.md).
+Event Hubs provides direct receivers and an easy consumer library called the [Event Processor](event-processor-balance-partition-load.md).
 
 - **Direct receivers** – The direct receivers listen to specific partitions. Their runtime behavior isn't affected when partitions are scaled out for an event hub. The application that uses direct receivers needs to take care of picking up the new partitions and assigning the receivers accordingly.
 - **Event processor host** – This client doesn't automatically refresh the entity metadata. So, it wouldn't pick up on partition count increase. Recreating an event processor instance will cause an entity metadata fetch, which in turn will create new blobs for the newly added partitions. Pre-existing blobs won't be affected. Restarting all event processor instances is recommended to ensure that all instances are aware of the newly added partitions, and load-balancing is handled correctly among consumers.

articles/event-hubs/event-hubs-c-getstarted-send.md

@@ -152,7 +152,7 @@ Congratulations! You have now sent messages to an event hub.
 ## Next steps
 Read the following articles:
 
-- [EventProcessorHost](event-hubs-event-processor-host.md)
+- [Event processor](event-processor-balance-partition-load.md)
 - [Features and terminology in Azure Event Hubs](event-hubs-features.md).
 
 

articles/event-hubs/event-hubs-event-processor-host.md

@@ -2,7 +2,7 @@
 title: Send or receive events from Azure Event Hubs using Java (latest)
 description: This article provides a walkthrough of creating a Java application that sends/receives events to/from Azure Event Hubs.
 ms.topic: quickstart
-ms.date: 02/10/2023
+ms.date: 02/16/2024
 ms.devlang: java
 ms.custom: devx-track-java, mode-api, passwordless-java, devx-track-extended-java
 ---
@@ -20,7 +20,7 @@ If you're new to Azure Event Hubs, see [Event Hubs overview](event-hubs-about.md
 
 To complete this quickstart, you need the following prerequisites:
 
-- **Microsoft Azure subscription**. To use Azure services, including Azure Event Hubs, you need a subscription.  If you don't have an existing Azure account, you can sign up for a [free trial](https://azure.microsoft.com/free/) or use your MSDN subscriber benefits when you [create an account](https://azure.microsoft.com).
+- **Microsoft Azure subscription**. To use Azure services, including Azure Event Hubs, you need a subscription. If you don't have an existing Azure account, you can sign up for a [free trial](https://azure.microsoft.com/free/) or use your MSDN subscriber benefits when you [create an account](https://azure.microsoft.com).
 - A Java development environment. This quickstart uses [Eclipse](https://www.eclipse.org/). Java Development Kit (JDK) with version 8 or above is required.
 - **Create an Event Hubs namespace and an event hub**. The first step is to use the [Azure portal](https://portal.azure.com) to create a namespace of type Event Hubs, and obtain the management credentials your application needs to communicate with the event hub. To create a namespace and an event hub, follow the procedure in [this article](event-hubs-create.md). Then, get the **connection string for the Event Hubs namespace** by following instructions from the article: [Get connection string](event-hubs-get-connection-string.md#azure-portal). You use the connection string later in this quickstart.
 
@@ -38,12 +38,12 @@ First, create a new **Maven** project for a console/shell application in your fa
 		<dependency>
 		    <groupId>com.azure</groupId>
 		    <artifactId>azure-messaging-eventhubs</artifactId>
-		    <version>5.15.0</version>
+		    <version>5.18.0</version>
 		</dependency>
 		<dependency>
 		    <groupId>com.azure</groupId>
 		    <artifactId>azure-identity</artifactId>
-		    <version>1.8.0</version>
+		    <version>1.11.2</version>
 		    <scope>compile</scope>
 		</dependency>
 ```
@@ -54,7 +54,7 @@ First, create a new **Maven** project for a console/shell application in your fa
 		<dependency>
 		    <groupId>com.azure</groupId>
 		    <artifactId>azure-messaging-eventhubs</artifactId>
-		    <version>5.15.0</version>
+		    <version>5.18.0</version>
 		</dependency>
 ```
 
@@ -233,7 +233,7 @@ Follow these steps to create an Azure Storage account.
 
 ## [Connection String](#tab/connection-string)
 
-[Get the connection string to the storage account](../storage/common/storage-configure-connection-string.md)
+[Get the connection string to the storage account](../storage/common/storage-configure-connection-string.md).
 
 Note down the **connection string** and the **container name**. You use them in the receive code. 
 

articles/event-hubs/event-hubs-features.md

@@ -2,7 +2,7 @@
 title: 'Quickstart: Use Apache Kafka with Azure Event Hubs'
 description: 'This quickstart shows you how to stream data into and from Azure Event Hubs using the Apache Kafka protocol.'
 ms.topic: quickstart
-ms.date: 02/07/2023
+ms.date: 02/16/2024
 author: spelluru
 ms.author: spelluru
 ms.custom: mode-other, passwordless-java
@@ -96,10 +96,8 @@ Azure Event Hubs supports using Microsoft Entra ID to authorize requests to Even
 ### [Connection string](#tab/connection-string)
 
 1. Clone the [Azure Event Hubs for Kafka repository](https://github.com/Azure/azure-event-hubs-for-kafka).
-
-1. Navigate to *azure-event-hubs-for-kafka/quickstart/java/producer*.
-
-1. Update the configuration details for the producer in *src/main/resources/producer.config* as follows:
+1. Navigate to *azure-event-hubs-for-kafka/quickstart/java/consumer*.
+1. Update the configuration details for the consumer in *src/main/resources/consumer.config* as follows:
 
    ```xml
    bootstrap.servers=NAMESPACENAME.servicebus.windows.net:9093
@@ -110,17 +108,14 @@ Azure Event Hubs supports using Microsoft Entra ID to authorize requests to Even
 
    > [!IMPORTANT]
    > Replace `{YOUR.EVENTHUBS.CONNECTION.STRING}` with the connection string for your Event Hubs namespace. For instructions on getting the connection string, see [Get an Event Hubs connection string](event-hubs-get-connection-string.md). Here's an example configuration: `sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="$ConnectionString" password="Endpoint=sb://mynamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=XXXXXXXXXXXXXXXX";`
+1. Run the consumer code and process events from event hub using your Kafka clients:
 
-1. Run the producer code and stream events into Event Hubs:
-
-   ```shell
+   ```java
    mvn clean package
-   mvn exec:java -Dexec.mainClass="TestProducer"
+   mvn exec:java -Dexec.mainClass="TestConsumer"
    ```
-
-1. Navigate to *azure-event-hubs-for-kafka/quickstart/java/consumer*.
-
-1. Update the configuration details for the consumer in *src/main/resources/consumer.config* as follows:
+1. Navigate to *azure-event-hubs-for-kafka/quickstart/java/producer*.
+1. Update the configuration details for the producer in *src/main/resources/producer.config* as follows:
 
    ```xml
    bootstrap.servers=NAMESPACENAME.servicebus.windows.net:9093
@@ -131,12 +126,11 @@ Azure Event Hubs supports using Microsoft Entra ID to authorize requests to Even
 
    > [!IMPORTANT]
    > Replace `{YOUR.EVENTHUBS.CONNECTION.STRING}` with the connection string for your Event Hubs namespace. For instructions on getting the connection string, see [Get an Event Hubs connection string](event-hubs-get-connection-string.md). Here's an example configuration: `sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="$ConnectionString" password="Endpoint=sb://mynamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=XXXXXXXXXXXXXXXX";`
+1. Run the producer code and stream events into Event Hubs:
 
-1. Run the consumer code and process events from event hub using your Kafka clients:
-
-   ```java
+   ```shell
    mvn clean package
-   mvn exec:java -Dexec.mainClass="TestConsumer"
+   mvn exec:java -Dexec.mainClass="TestProducer"
    ```
 
 If your Event Hubs Kafka cluster has events, you'll now start receiving them from the consumer.

articles/event-hubs/event-hubs-java-get-started-send.md

@@ -7,7 +7,7 @@ ms.date: 11/14/2022
 
 # Balance partition load across multiple instances of your application
 
-To scale your event processing application, you can run multiple instances of the application and have the load balanced among themselves. In the older versions, [EventProcessorHost](event-hubs-event-processor-host.md) allowed you to balance the load between multiple instances of your program and checkpoint events when receiving the events. In the newer versions (5.0 onwards), **EventProcessorClient** (.NET and Java), or **EventHubConsumerClient** (Python and JavaScript) allows you to do the same. The development model is made simpler by using events. You subscribe to the events that you're interested in by registering an event handler. If you're using the old version of the client library, see the following migration guides: [.NET](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/eventhub/Azure.Messaging.EventHubs/MigrationGuide.md), [Java](https://github.com/Azure/azure-sdk-for-java/blob/master/sdk/servicebus/azure-messaging-servicebus/migration-guide.md), [Python](https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/servicebus/azure-servicebus/migration_guide.md), and [JavaScript](https://github.com/Azure/azure-sdk-for-js/blob/master/sdk/servicebus/service-bus/migrationguide.md).
+To scale your event processing application, you can run multiple instances of the application and have the load balanced among themselves. In the older and deprecated versions, `EventProcessorHost` allowed you to balance the load between multiple instances of your program and checkpoint events when receiving the events. In the newer versions (5.0 onwards), **EventProcessorClient** (.NET and Java), or **EventHubConsumerClient** (Python and JavaScript) allows you to do the same. The development model is made simpler by using events. You can subscribe to the events that you're interested in by registering an event handler. If you're using the old version of the client library, see the following migration guides: [.NET](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/eventhub/Azure.Messaging.EventHubs/MigrationGuide.md), [Java](https://github.com/Azure/azure-sdk-for-java/blob/master/sdk/servicebus/azure-messaging-servicebus/migration-guide.md), [Python](https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/servicebus/azure-servicebus/migration_guide.md), and [JavaScript](https://github.com/Azure/azure-sdk-for-js/blob/master/sdk/servicebus/service-bus/migrationguide.md).
 
 This article describes a sample scenario for using multiple instances of client `applications to read events from an event hub. It also gives you details about features of event processor client, which allows you to receive events from multiple partitions at once and load balance with other consumers that use the same event hub and consumer group.
 
@@ -22,7 +22,7 @@ Each sensor pushes data to an event hub. The event hub is configured with 16 par
 
 ## Consumer application
 
-When designing the consumer in a distributed environment, the scenario must handle the following requirements:
+When you design a consumer in a distributed environment, the scenario must handle the following requirements:
 
 1. **Scale:** Create multiple consumers, with each consumer taking ownership of reading from a few Event Hubs partitions.
 2. **Load balance:** Increase or reduce the consumers dynamically. For example, when a new sensor type (for example, a carbon monoxide detector) is added to each home, the number of events increases. In that case, the operator (a human) increases the number of consumer instances. Then, the pool of consumers can rebalance the number of partitions they own, to share the load with the newly added consumers.
@@ -58,7 +58,7 @@ Each event processor instance acquires ownership of a partition and starts proce
 
 ## Receive messages
 
-When you create an event processor, you specify functions that will process events and errors. Each call to the function that processes events delivers a single event from a specific partition. It's your responsibility to handle this event. If you want to make sure the consumer processes every message at least once, you need to write your own code with retry logic. But be cautious about poisoned messages.
+When you create an event processor, you specify functions that process events and errors. Each call to the function that processes events delivers a single event from a specific partition. It's your responsibility to handle this event. If you want to make sure the consumer processes every message at least once, you need to write your own code with retry logic. But be cautious about poisoned messages.
 
 We recommend that you do things relatively fast. That is, do as little processing as possible. If you need to write to storage and do some routing, it's better to use two consumer groups and have two event processors.
 

articles/event-hubs/event-hubs-quickstart-kafka-enabled-event-hubs.md

@@ -1,6 +1,6 @@
 ---
-title: include file
-description: include file
+title: Event Hubs partition overview
+description: Provides a description of a partition in Azure Event Hubs. 
 author: spelluru
 ms.service: event-hubs
 ms.topic: include
@@ -10,6 +10,6 @@ ms.custom: "include file"
 
 ---
 
-As [partition](../event-hubs-features.md#partitions) is a data organization mechanism that allows you to publish and consume data in a parallel manner, we recommend that you balance scaling units (TUs, PUs or CUs) and partitions to achieve optimal scale. In general, we recommend a maximum throughput of 1 MB/s per partition. Therefore, a rule of thumb for calculating the number of partitions would be to divide the maximum expected throughput by 1 MB/s. For example, if your use case requires 20 MB/s, it is recommended to choose at least 20 partitions to achieve the optimal throughput.                             
+As [partition](../event-hubs-features.md#partitions) is a data organization mechanism that allows you to publish and consume data in a parallel manner. We recommend that you balance scaling units (throughput units for the standard tier, processing units for the premium tier, or capacity units for the dedicated tier) and partitions to achieve optimal scale. In general, we recommend a maximum throughput of 1 MB/s per partition. Therefore, a rule of thumb for calculating the number of partitions would be to divide the maximum expected throughput by 1 MB/s. For example, if your use case requires 20 MB/s, we recommend that you choose at least 20 partitions to achieve the optimal throughput.                             
 
-However, if you have a model in which your application has an affinity to a particular partition, increasing the number of partitions may not be beneficial. For more information, see [availability and consistency](../event-hubs-availability-and-consistency.md).
+However, if you have a model in which your application has an affinity to a particular partition, increasing the number of partitions isn't beneficial. For more information, see [availability and consistency](../event-hubs-availability-and-consistency.md).