[Event Hubs] Fix sending Uint8Array (Azure#21185)

### Packages impacted by this PR
@azure/event-hubs

### Issues associated with this PR
Fixes Azure#21184

### Describe the problem that is addressed by this PR
When sending a message with `Uint8Array` (which is not strictly a `Buffer`), the client will stringify the payload first, see the last branch in:
https://github.com/Azure/azure-sdk-for-js/blob/7926782dcb48b46cafe51cf1648d9c53b5320ec7/sdk/eventhub/event-hubs/src/dataTransformer.ts#L42-L67

This behavior forces the receiver on the other end to unnecessarily unstringify the payload first.

### What are the possible designs available to address the problem? If there are more than one possible design, why was the one in this PR chosen?

The design proposed in this PR is to handle the Uint8Array case the same as Buffer but that is a breaking change.

This problem mainly affects sending avro-serialized payloads so alternatively, without introducing breaking changes, the message adapter can convert Uint8Array to a Buffer before handing it to the client for sending. This could work but will likely create confusion for customers who send Uint8Array payloads coming from both the serializer and other sources.

### Are there test cases added in this PR? _(If not, why?)_
Will be added after approval.

### Provide a list of related PRs _(if any)_
N/A

### Command used to generate this PR:**_(Applicable only to SDK release request PRs)_

### Checklists
- [x] Added impacted package name to the issue description
- [ ] Does this PR needs any fixes in the SDK Generator?** _(If so, create an Issue in the [Autorest/typescript](https://github.com/Azure/autorest.typescript) repository and link it here)_
- [ ] Added a changelog (if necessary)

Author: deyaaeldeen

sdk/eventhub/event-hubs/CHANGELOG.md

@@ -8,6 +8,7 @@
 - `MessageAdapter`'s `consumeMessage` and `produceMessage` have been renamed to `consume` and `produce`.
 
 ### Bugs Fixed
+- The Uint8Array payload was being stringified first before it gets sent which caused the receiver to treat it as an object instead of a Uint8Array. This is now fixed and Uint8Array is being treated the same as a Buffer.
 - The hashing algorithm used to map partition keys to IDs in the buffered producer is no longer sensitive to the endianness of the local machine [Issue #21190](https://github.com/Azure/azure-sdk-for-js/issues/21190).
 
 ### Other Changes

sdk/eventhub/event-hubs/src/dataTransformer.ts

@@ -46,7 +46,7 @@ export const defaultDataTransformer = {
       result.typecode = valueSectionTypeCode;
     } else if (bodyType === "sequence") {
       result = message.sequence_section(body);
-    } else if (isBuffer(body)) {
+    } else if (isBuffer(body) || body instanceof Uint8Array) {
       result = message.data_section(body);
     } else if (body === null && bodyType === "data") {
       result = message.data_section(null);

sdk/eventhub/event-hubs/test/public/eventHubConsumerClient.spec.ts

@@ -18,7 +18,7 @@ import { EnvVarKeys, getEnvVars, getStartingPositionsForTests, loopUntil } from
 import { LogTester } from "./utils/logHelpers";
 import { ReceivedMessagesTester } from "./utils/receivedMessagesTester";
 import { TestInMemoryCheckpointStore } from "./utils/testInMemoryCheckpointStore";
-import chai from "chai";
+import chai, { expect } from "chai";
 import { createMockServer } from "./utils/mockService";
 import debugModule from "debug";
 import { testWithServiceTypes } from "./utils/testWithServiceTypes";
@@ -1267,5 +1267,41 @@ testWithServiceTypes((serviceVersion) => {
         should.equal((caughtErr as MessagingError).code, "ArgumentOutOfRangeError");
       });
     });
+
+    describe("Types of received payloads", function (): void {
+      it(`Uint8Array is received as Buffer`, async function (): Promise<void> {
+        const partitionId = partitionIds[0];
+        const startingPositions = await getStartingPositionsForTests(consumerClient);
+        const data = [0, 1, 2];
+        await producerClient.sendBatch(
+          [{ body: Uint8Array.from(data), contentType: "avro/binary+1234" }],
+          {
+            partitionId,
+          }
+        );
+        let subscription: Subscription;
+        const receivedEvent = await new Promise<ReceivedEventData>((resolve, reject) => {
+          subscription = consumerClient.subscribe(
+            partitionId,
+            {
+              processEvents: async (events: ReceivedEventData[]) => {
+                resolve(events[0]);
+              },
+              processError: async (err) => {
+                reject(err);
+              },
+            },
+            {
+              startPosition: startingPositions,
+            }
+          );
+        });
+        await subscription!.close();
+        should.exist(receivedEvent);
+        const body = receivedEvent.body as Buffer;
+        expect(Buffer.isBuffer(body)).to.be.true;
+        expect(body.toJSON().data).to.be.deep.equal(data);
+      });
+    });
   }).timeout(120000);
 });

sdk/schemaregistry/schema-registry-avro/samples-dev/withEventHubsBufferedProducerClient.ts

@@ -24,6 +24,9 @@ const groupName = process.env["SCHEMA_REGISTRY_GROUP"] || "AzureSdkSampleGroup";
 // The connection string for Event Hubs
 const eventHubsConnectionString = process.env["EVENTHUB_CONNECTION_STRING"] || "";
 
+// The name of Event Hub the client will connect to
+const eventHubName = process.env["EVENTHUB_NAME"] || "";
+
 // Sample Avro Schema for user with first and last names
 const schemaObject = {
   type: "record",
@@ -81,6 +84,7 @@ export async function main() {
 
   const eventHubsBufferedProducerClient = new EventHubBufferedProducerClient(
     eventHubsConnectionString,
+    eventHubName,
     {
       onSendEventsErrorHandler: handleError,
     }