fix(service-bus): Read max-message-batch-size vendor property for batch sizing (#38049)

## Problem

On Premium large-message Service Bus entities, the AMQP link's
`max-message-size` can be up to 100 MB, but the broker enforces a 1 MB
limit for batch sends. The JS SDK reads `max-message-size` (via
`this.link.maxMessageSize`) for batch sizing, so `createMessageBatch()`
accepts batches up to 100 MB that the broker then rejects.

Related:
[azure-service-bus#708](Azure/azure-service-bus#708)

## Fix

Read the `com.microsoft:max-message-batch-size` vendor property from the
AMQP sender link attach frame, which correctly reports 256 KB (Standard)
/ 1 MB (Premium) independent of entity-level `max-message-size`. When
the vendor property is absent (older service versions), fall back to
`Math.min(maxMessageSize, defaultMaxBatchSize)` where
`defaultMaxBatchSize` is 1 MB — this caps the batch size to prevent
using the raw `max-message-size` (which can be up to 100 MB on Premium
large-message entities).

### Changes

- **`messageSender.ts`**: Add `defaultMaxBatchSize` constant (1 MB); add
`getMaxBatchSizeFromLink()` that reads the vendor property from
`this.link.properties`, falling back to `Math.min(maxMessageSize,
defaultMaxBatchSize)`; update `createBatch()` to use the new method
- **`messageSender.spec.ts`**: Unit tests for vendor property present,
absent (with 1 MB cap), undefined properties, wrong type, zero value,
user override, rejection of oversized `maxSizeInBytes`, Standard tier

### Cross-SDK alignment

| SDK | Status |
|-----|--------|
| .NET | [PR
#57941](Azure/azure-sdk-for-net#57941) |
| Java | [PR
#48214](Azure/azure-sdk-for-java#48214) |
| Go | [PR #26530](Azure/azure-sdk-for-go#26530)
|
| Python | [PR
#46197](Azure/azure-sdk-for-python#46197) |

---------

Co-authored-by: Eldert Grootenboer (from Dev Box) <egrootenboer@microsoft.com>

Author: EldertGrootenboer

sdk/servicebus/service-bus/CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Bugs Fixed
 
+- Read `com.microsoft:max-message-batch-size` vendor property from the AMQP sender link to correctly limit batch size on Premium large-message entities, where `max-message-size` can be up to 100 MB but the batch limit is 1 MB.
 - Fixed `TimeoutNegativeWarning` on Node.js v24+ when timeout budget is exceeded during CBS authentication by clamping remaining-time computations to a minimum of 0. [#38166](https://github.com/Azure/azure-sdk-for-js/pull/38166)
 
 ### Other Changes

sdk/servicebus/service-bus/src/core/messageSender.ts

@@ -32,6 +32,13 @@ import { ServiceBusError, translateServiceBusError } from "../serviceBusError.js
 import { isDefined } from "@azure/core-util";
 import { defaultDataTransformer } from "../dataTransformer.js";
 
+/**
+ * Default maximum batch size (1 MB). Used when the service does not
+ * advertise a batch size limit on the AMQP link.
+ * @internal
+ */
+const defaultMaxBatchSize = 1048576;
+
 /**
  * @internal
  * Describes the MessageSender that will send messages to ServiceBus.
@@ -395,22 +402,48 @@ export class MessageSender extends LinkEntity<AwaitableSender> {
     return retry(config);
   }
 
+  /**
+   * Returns the maximum batch size allowed by the service, reading the
+   * vendor-specific batch size property from the AMQP link if available.
+   * Falls back to `Math.min(maxMessageSize, defaultMaxBatchSize)` when
+   * the property is absent or invalid.
+   */
+  private getMaxBatchSizeFromLink(): number {
+    if (this.link) {
+      const vendorBatchSize = this.link.properties?.["com.microsoft:max-message-batch-size"];
+      if (typeof vendorBatchSize === "number" && vendorBatchSize > 0) {
+        return vendorBatchSize;
+      }
+    }
+    // Fallback: cap at defaultMaxBatchSize to avoid using the raw
+    // max-message-size (which can be 100 MB on Premium large-message entities)
+    // as the batch limit.  Matches the .NET SDK pattern.
+    const maxMessageSize = this.link?.maxMessageSize ?? 0;
+    return maxMessageSize > 0 ? Math.min(maxMessageSize, defaultMaxBatchSize) : 0;
+  }
+
   async createBatch(options?: CreateMessageBatchOptions): Promise<ServiceBusMessageBatch> {
     throwErrorIfConnectionClosed(this._context);
-    let maxMessageSize = await this.getMaxMessageSize({
+    // Ensure the link is open so we can read link properties.
+    const maxMessageSize = await this.getMaxMessageSize({
       retryOptions: this._retryOptions,
       abortSignal: options?.abortSignal,
     });
+    // Use the vendor batch size if available; fall back to
+    // min(maxMessageSize, defaultMaxBatchSize) to prevent using the raw
+    // max-message-size as the batch limit on large-message entities.
+    let maxBatchSize =
+      this.getMaxBatchSizeFromLink() || Math.min(maxMessageSize, defaultMaxBatchSize);
     if (options?.maxSizeInBytes) {
-      if (options.maxSizeInBytes > maxMessageSize!) {
+      if (options.maxSizeInBytes > maxBatchSize) {
         const error = new Error(
-          `Max message size (${options.maxSizeInBytes} bytes) is greater than maximum message size (${maxMessageSize} bytes) on the AMQP sender link.`,
+          `Requested max batch size (${options.maxSizeInBytes} bytes) exceeds the maximum batch size (${maxBatchSize} bytes) on the AMQP sender link.`,
         );
         throw error;
       }
-      maxMessageSize = options.maxSizeInBytes;
+      maxBatchSize = options.maxSizeInBytes;
     }
-    return new ServiceBusMessageBatchImpl(this._context, maxMessageSize!);
+    return new ServiceBusMessageBatchImpl(this._context, maxBatchSize);
   }
 
   async sendBatch(

sdk/servicebus/service-bus/test/internal/unit/messageSender.spec.ts

@@ -183,4 +183,222 @@ describe("MessageSender unit tests", () => {
 
     assert.equal(openCalled, retryOptions.maxRetries + 1);
   });
+
+  describe("createBatch uses vendor property for batch sizing", () => {
+    function createSender(): MessageSender {
+      return new MessageSender(
+        "serviceBusClientId",
+        createConnectionContextForTests(),
+        "entityPath",
+        { maxRetries: 0, retryDelayInMs: 0, timeoutInMs: 1000 },
+      );
+    }
+
+    it("prefers com.microsoft:max-message-batch-size over maxMessageSize", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 100 * 1024 * 1024, // 100 MB (Premium large-message)
+          properties: {
+            "com.microsoft:max-message-batch-size": 1048576, // 1 MB
+          },
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        1048576,
+        "Batch size should use vendor property (1 MB), not maxMessageSize (100 MB)",
+      );
+    });
+
+    it("falls back to Math.min(maxMessageSize, defaultMaxBatchSize) when vendor property is absent", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 262144, // 256 KB (Standard tier)
+          properties: {},
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        262144,
+        "Batch size should be Math.min(maxMessageSize, defaultMaxBatchSize) = Math.min(256KB, 1MB) = 256KB",
+      );
+    });
+
+    it("falls back to Math.min(maxMessageSize, defaultMaxBatchSize) when properties dict is undefined", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 262144,
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        262144,
+        "Batch size should be Math.min(maxMessageSize, defaultMaxBatchSize) when properties is undefined",
+      );
+    });
+
+    it("falls back to capped size when vendor property has wrong type", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 262144,
+          properties: {
+            "com.microsoft:max-message-batch-size": "not-a-number",
+          },
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        262144,
+        "Batch size should fall back to Math.min(maxMessageSize, defaultMaxBatchSize) when vendor property is not a number",
+      );
+    });
+
+    it("falls back to capped size when vendor property is zero", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 262144,
+          properties: {
+            "com.microsoft:max-message-batch-size": 0,
+          },
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        262144,
+        "Batch size should fall back to Math.min(maxMessageSize, defaultMaxBatchSize) when vendor property is zero",
+      );
+    });
+
+    it("user-specified maxSizeInBytes still takes precedence over vendor property", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 100 * 1024 * 1024,
+          properties: {
+            "com.microsoft:max-message-batch-size": 1048576,
+          },
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch({ maxSizeInBytes: 512 });
+      assert.equal(
+        batch.maxSizeInBytes,
+        512,
+        "User-specified maxSizeInBytes should override vendor property",
+      );
+    });
+
+    it("rejects user-specified maxSizeInBytes above vendor batch limit", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 100 * 1024 * 1024,
+          properties: {
+            "com.microsoft:max-message-batch-size": 1048576,
+          },
+          isOpen: () => true,
+        } as any;
+      };
+
+      try {
+        await sender.createBatch({ maxSizeInBytes: 2 * 1024 * 1024 });
+        assert.fail("Should have thrown for maxSizeInBytes > batch limit");
+      } catch (e: any) {
+        assert.include(e.message, "Requested max batch size");
+      }
+    });
+
+    it("Standard tier uses 256 KB from vendor property", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 262144, // 256 KB (Standard)
+          properties: {
+            "com.microsoft:max-message-batch-size": 262144,
+          },
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(batch.maxSizeInBytes, 262144, "Standard tier should use 256 KB batch size");
+    });
+
+    it("caps batch size at 1 MB when vendor property is absent and maxMessageSize is 100 MB", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 100 * 1024 * 1024, // 100 MB (Premium large-message)
+          properties: {},
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        1048576,
+        "Batch size should be capped at 1 MB (defaultMaxBatchSize) when vendor property is absent, even if maxMessageSize is 100 MB",
+      );
+    });
+
+    it("caps batch size at 1 MB when vendor property is absent and maxMessageSize is 2 MB", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 2 * 1024 * 1024, // 2 MB
+          properties: {},
+          isOpen: () => true,
+        } as any;
+      };
+
+      const batch = await sender.createBatch();
+      assert.equal(
+        batch.maxSizeInBytes,
+        1048576,
+        "Batch size should be capped at 1 MB even when maxMessageSize is only slightly larger",
+      );
+    });
+
+    it("rejects user-specified maxSizeInBytes above capped batch limit (no vendor property)", async () => {
+      const sender = createSender();
+      sender["open"] = async () => {
+        sender["_link"] = {
+          maxMessageSize: 100 * 1024 * 1024, // 100 MB
+          properties: {},
+          isOpen: () => true,
+        } as any;
+      };
+
+      try {
+        // Without the cap, this would succeed (2 MB < 100 MB).
+        // With the cap, it should fail (2 MB > 1 MB cap).
+        await sender.createBatch({ maxSizeInBytes: 2 * 1024 * 1024 });
+        assert.fail("Should have thrown for maxSizeInBytes > capped batch limit");
+      } catch (e: any) {
+        assert.include(e.message, "Requested max batch size");
+      }
+    });
+  });
 });