@azure/event-hubs 6.0.2-alpha.20251014.1 → 6.0.2-alpha.20251021.1

package/dist/react-native/eventDataBatch.js

@@ -0,0 +1,301 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { assertIsEventData, isAmqpAnnotatedMessage, populateIdempotentMessageAnnotations, toRheaMessage, } from "./eventData.js";
+import { message } from "rhea-promise";
+import { isDefined, isObjectWithProperties } from "@azure/core-util";
+import { instrumentEventData } from "./diagnostics/instrumentEventData.js";
+import { throwTypeErrorIfParameterMissing } from "./util/error.js";
+/**
+ * The amount of bytes to reserve as overhead for a small message.
+ */
+const smallMessageOverhead = 5;
+/**
+ * The amount of bytes to reserve as overhead for a large message.
+ */
+const largeMessageOverhead = 8;
+/**
+ * The maximum number of bytes that a message may be to be considered small.
+ */
+const smallMessageMaxBytes = 255;
+/**
+ * Checks if the provided eventDataBatch is an instance of `EventDataBatch`.
+ * @param eventDataBatch - The instance of `EventDataBatch` to verify.
+ * @internal
+ */
+export function isEventDataBatch(eventDataBatch) {
+    return (isObjectWithProperties(eventDataBatch, ["count", "sizeInBytes", "tryAdd"]) &&
+        typeof eventDataBatch.tryAdd === "function" &&
+        typeof eventDataBatch.count === "number" &&
+        typeof eventDataBatch.sizeInBytes === "number");
+}
+/**
+ * An internal class representing a batch of events which can be used to send events to Event Hub.
+ *
+ * @internal
+ */
+export class EventDataBatchImpl {
+    /**
+     * Describes the amqp connection context for the Client.
+     */
+    _context;
+    /**
+     * The Id of the partition to which the batch is expected to be sent to.
+     * Specifying this will throw an error if the batch was created using a `partitionKey`.
+     */
+    _partitionId;
+    /**
+     * A value that is hashed to produce a partition assignment.
+     * It guarantees that messages with the same partitionKey end up in the same partition.
+     * Specifying this will throw an error if the batch was created using a `partitionId`.
+     */
+    _partitionKey;
+    /**
+     * The maximum size allowed for the batch.
+     */
+    _maxSizeInBytes;
+    /**
+     * Current size of the batch in bytes.
+     */
+    _sizeInBytes;
+    /**
+     * Encoded amqp messages.
+     */
+    _encodedMessages = [];
+    /**
+     * Number of events in the batch.
+     */
+    _count;
+    /**
+     * List of 'message' span contexts.
+     */
+    _spanContexts = [];
+    /**
+     * The message annotations to apply on the batch envelope.
+     * This will reflect the message annotations on the first event
+     * that was added to the batch.
+     * A common annotation is the partition key.
+     */
+    _batchAnnotations;
+    /**
+     * Indicates that the batch should be treated as idempotent.
+     */
+    _isIdempotent;
+    /**
+     * The sequence number assigned to the first event in the batch while
+     * the batch is being sent to the service.
+     */
+    _pendingStartingSequenceNumber;
+    /**
+     * The publishing sequence number assigned to the first event in the batch at the time
+     * the batch was successfully published.
+     * If the producer was not configured to apply sequence numbering or if the batch
+     * has not yet been successfully published, the value will be `undefined`.
+     */
+    _startingPublishSequenceNumber;
+    /**
+     * EventDataBatch should not be constructed using `new EventDataBatch()`
+     * Use the `createBatch()` method on your `EventHubProducer` instead.
+     * @internal
+     */
+    constructor(context, maxSizeInBytes, isIdempotent, partitionKey, partitionId) {
+        this._context = context;
+        this._maxSizeInBytes = maxSizeInBytes;
+        this._isIdempotent = isIdempotent;
+        this._partitionKey = isDefined(partitionKey) ? String(partitionKey) : partitionKey;
+        this._partitionId = isDefined(partitionId) ? String(partitionId) : partitionId;
+        this._sizeInBytes = 0;
+        this._count = 0;
+    }
+    /**
+     * The maximum size of the batch, in bytes.
+     * @readonly
+     */
+    get maxSizeInBytes() {
+        return this._maxSizeInBytes;
+    }
+    /**
+     * The partitionKey set during `EventDataBatch` creation. This value is hashed to
+     * produce a partition assignment when the producer is created without a `partitionId`
+     * @readonly
+     */
+    get partitionKey() {
+        return this._partitionKey;
+    }
+    /**
+     * The partitionId set during `EventDataBatch` creation.
+     * If this value is set then partitionKey can not be set.
+     * @readonly
+     */
+    get partitionId() {
+        return this._partitionId;
+    }
+    /**
+     * Size of the `EventDataBatch` instance after the events added to it have been
+     * encoded into a single AMQP message.
+     * @readonly
+     */
+    get sizeInBytes() {
+        return this._sizeInBytes;
+    }
+    /**
+     * Number of events in the `EventDataBatch` instance.
+     * @readonly
+     */
+    get count() {
+        return this._count;
+    }
+    /**
+     * The publishing sequence number assigned to the first event in the batch at the time
+     * the batch was successfully published.
+     * If the producer was not configured to apply sequence numbering or if the batch
+     * has not yet been successfully published, the value will be `undefined`.
+     */
+    get startingPublishedSequenceNumber() {
+        return this._startingPublishSequenceNumber;
+    }
+    /**
+     * Gets the "message" span contexts that were created when adding events to the batch.
+     * @internal
+     */
+    get _messageSpanContexts() {
+        return this._spanContexts;
+    }
+    /**
+     * Generates an AMQP message that contains the provided encoded events and annotations.
+     * @param encodedEvents - The already encoded events to include in the AMQP batch.
+     * @param annotations - The message annotations to set on the batch.
+     * @param publishingProps - Idempotent publishing properties used to decorate the events in the batch while sending.
+     */
+    _generateBatch(encodedEvents, annotations, publishingProps) {
+        if (this._isIdempotent && publishingProps) {
+            // We need to decode the encoded events, add the idempotent annotations, and re-encode them.
+            // We can't lazily encode the events because we rely on `message.encode` to capture the
+            // byte length of anything not in `event.body`.
+            // Events can't be decorated ahead of time because the publishing properties aren't known
+            // until the events are being sent to the service.
+            const decodedEvents = encodedEvents.map(message.decode);
+            const decoratedEvents = this._decorateRheaMessagesWithPublishingProps(decodedEvents, publishingProps);
+            encodedEvents = decoratedEvents.map(message.encode);
+        }
+        const batchEnvelope = {
+            body: message.data_sections(encodedEvents),
+        };
+        if (annotations) {
+            batchEnvelope.message_annotations = annotations;
+        }
+        return message.encode(batchEnvelope);
+    }
+    /**
+     * Uses the publishingProps to add idempotent properties as message annotations to rhea messages.
+     */
+    _decorateRheaMessagesWithPublishingProps(events, publishingProps) {
+        if (!this._isIdempotent) {
+            return events;
+        }
+        const { lastPublishedSequenceNumber = 0, ownerLevel, producerGroupId } = publishingProps;
+        const startingSequenceNumber = lastPublishedSequenceNumber + 1;
+        for (let i = 0; i < events.length; i++) {
+            const event = events[i];
+            populateIdempotentMessageAnnotations(event, {
+                isIdempotentPublishingEnabled: this._isIdempotent,
+                ownerLevel,
+                producerGroupId,
+                publishSequenceNumber: startingSequenceNumber + i,
+            });
+        }
+        this._pendingStartingSequenceNumber = startingSequenceNumber;
+        return events;
+    }
+    /**
+     * Annotates a rhea message with placeholder idempotent properties if the batch is idempotent.
+     * This is necessary so that we can accurately calculate the size of the batch while adding events.
+     * Placeholder values are used because real values won't be known until we attempt to send the batch.
+     */
+    _decorateRheaMessageWithPlaceholderIdempotencyProps(event) {
+        if (!this._isIdempotent) {
+            return event;
+        }
+        if (!event.message_annotations) {
+            event.message_annotations = {};
+        }
+        // Set placeholder values for these annotations.
+        populateIdempotentMessageAnnotations(event, {
+            isIdempotentPublishingEnabled: this._isIdempotent,
+            ownerLevel: 0,
+            publishSequenceNumber: 0,
+            producerGroupId: 0,
+        });
+        return event;
+    }
+    /**
+     * Generates the single AMQP message which is the result of encoding all the events
+     * added into the `EventDataBatch` instance.
+     *
+     * This is not meant for the user to use directly.
+     *
+     * When the `EventDataBatch` instance is passed to the `send()` method on the `EventHubProducer`,
+     * this single batched AMQP message is what gets sent over the wire to the service.
+     * @readonly
+     */
+    _generateMessage(publishingProps) {
+        return this._generateBatch(this._encodedMessages, this._batchAnnotations, publishingProps);
+    }
+    /**
+     * Sets startingPublishSequenceNumber to the pending publish sequence number.
+     */
+    _commitPublish() {
+        this._startingPublishSequenceNumber = this._pendingStartingSequenceNumber;
+    }
+    /**
+     * Tries to add an event data to the batch if permitted by the batch's size limit.
+     * **NOTE**: Always remember to check the return value of this method, before calling it again
+     * for the next event.
+     *
+     * @param eventData -  An individual event data object.
+     * @returns A boolean value indicating if the event data has been added to the batch or not.
+     */
+    tryAdd(eventData, options = {}) {
+        throwTypeErrorIfParameterMissing(this._context.connectionId, "tryAdd", "eventData", eventData);
+        if (!isAmqpAnnotatedMessage(eventData)) {
+            assertIsEventData(eventData);
+        }
+        const { entityPath, host } = this._context.config;
+        const { event: instrumentedEvent, spanContext } = instrumentEventData(eventData, options, entityPath, host);
+        // Convert EventData to RheaMessage.
+        const amqpMessage = toRheaMessage(instrumentedEvent, this._partitionKey);
+        const originalAnnotations = amqpMessage.message_annotations && {
+            ...amqpMessage.message_annotations,
+        };
+        this._decorateRheaMessageWithPlaceholderIdempotencyProps(amqpMessage);
+        const encodedMessage = message.encode(amqpMessage);
+        let currentSize = this._sizeInBytes;
+        // The first time an event is added, we need to calculate
+        // the overhead of creating an AMQP batch, including the
+        // message_annotations that are taken from the 1st message.
+        if (this.count === 0) {
+            if (originalAnnotations) {
+                this._batchAnnotations = originalAnnotations;
+            }
+            // Figure out the overhead of creating a batch by generating an empty batch
+            // with the expected batch annotations.
+            currentSize += this._generateBatch([], this._batchAnnotations).length;
+        }
+        const messageSize = encodedMessage.length;
+        const messageOverhead = messageSize <= smallMessageMaxBytes ? smallMessageOverhead : largeMessageOverhead;
+        currentSize += messageSize + messageOverhead;
+        // Check if the size of the batch exceeds the maximum allowed size
+        // once we add the new event to it.
+        if (currentSize > this._maxSizeInBytes) {
+            return false;
+        }
+        // The event will fit in the batch, so it is now safe to store it.
+        this._encodedMessages.push(encodedMessage);
+        if (spanContext) {
+            this._spanContexts.push(spanContext);
+        }
+        this._sizeInBytes = currentSize;
+        this._count++;
+        return true;
+    }
+}
+//# sourceMappingURL=eventDataBatch.js.map

package/dist/react-native/eventDataBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventDataBatch.js","sourceRoot":"","sources":["../../src/eventDataBatch.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { AmqpAnnotatedMessage } from \"@azure/core-amqp\";\nimport type { EventData } from \"./eventData.js\";\nimport {\n  assertIsEventData,\n  isAmqpAnnotatedMessage,\n  populateIdempotentMessageAnnotations,\n  toRheaMessage,\n} from \"./eventData.js\";\nimport type { ConnectionContext } from \"./connectionContext.js\";\nimport type { MessageAnnotations, Message as RheaMessage } from \"rhea-promise\";\nimport { message } from \"rhea-promise\";\nimport { isDefined, isObjectWithProperties } from \"@azure/core-util\";\nimport type { OperationTracingOptions, TracingContext } from \"@azure/core-tracing\";\nimport { instrumentEventData } from \"./diagnostics/instrumentEventData.js\";\nimport { throwTypeErrorIfParameterMissing } from \"./util/error.js\";\nimport type { PartitionPublishingProperties } from \"./models/private.js\";\n\n/**\n * The amount of bytes to reserve as overhead for a small message.\n */\nconst smallMessageOverhead = 5;\n/**\n * The amount of bytes to reserve as overhead for a large message.\n */\nconst largeMessageOverhead = 8;\n/**\n * The maximum number of bytes that a message may be to be considered small.\n */\nconst smallMessageMaxBytes = 255;\n\n/**\n * Checks if the provided eventDataBatch is an instance of `EventDataBatch`.\n * @param eventDataBatch - The instance of `EventDataBatch` to verify.\n * @internal\n */\nexport function isEventDataBatch(eventDataBatch: unknown): eventDataBatch is EventDataBatch {\n  return (\n    isObjectWithProperties(eventDataBatch, [\"count\", \"sizeInBytes\", \"tryAdd\"]) &&\n    typeof eventDataBatch.tryAdd === \"function\" &&\n    typeof eventDataBatch.count === \"number\" &&\n    typeof eventDataBatch.sizeInBytes === \"number\"\n  );\n}\n\n/**\n * Options to configure the behavior of the `tryAdd` method on the `EventDataBatch` class.\n */\nexport interface TryAddOptions {\n  /**\n   * The options to use when creating Spans for tracing.\n   */\n  tracingOptions?: OperationTracingOptions;\n}\n\n/**\n * An interface representing a batch of events which can be used to send events to Event Hub.\n *\n * To create the batch, use the `createBatch()` method on the `EventHubProducerClient`.\n * To send the batch, use the `sendBatch()` method on the same client.\n * To fill the batch, use the `tryAdd()` method on the batch itself.\n *\n */\nexport interface EventDataBatch {\n  /**\n   * A value that is hashed and used by the Azure Event Hubs service to determine the partition to\n   * which the events are sent. Use the `createBatch()` method on the `EventHubProducerClient` to\n   * set the partitionKey.\n   * @readonly\n   * @internal\n   */\n  readonly partitionKey?: string;\n\n  /**\n   * Id of the partition to which the batch of events are sent. Use the `createBatch()` method on\n   * the `EventHubProducerClient` to set the partitionId.\n   * @readonly\n   * @internal\n   */\n  readonly partitionId?: string;\n\n  /**\n   * Size of the batch in bytes after the events added to it have been encoded into a single AMQP\n   * message.\n   * @readonly\n   */\n  readonly sizeInBytes: number;\n\n  /**\n   * Number of events added to the batch.\n   * @readonly\n   */\n  readonly count: number;\n\n  /**\n   * The maximum size of the batch, in bytes. The `tryAdd` function on the batch will return `false`\n   * if the event being added causes the size of the batch to exceed this limit. Use the `createBatch()` method on\n   * the `EventHubProducerClient` to set the maxSizeInBytes.\n   * @readonly\n   */\n  readonly maxSizeInBytes: number;\n\n  /**\n   * Adds an event to the batch if permitted by the batch's size limit.\n   * **NOTE**: Always remember to check the return value of this method, before calling it again\n   * for the next event.\n   *\n   * @param eventData -  An individual event data object or AmqpAnnotatedMessage.\n   * @returns A boolean value indicating if the event data has been added to the batch or not.\n   */\n  tryAdd(eventData: EventData | AmqpAnnotatedMessage, options?: TryAddOptions): boolean;\n}\n\n/**\n * An internal class representing a batch of events which can be used to send events to Event Hub.\n *\n * @internal\n */\nexport class EventDataBatchImpl implements EventDataBatch {\n  /**\n   * Describes the amqp connection context for the Client.\n   */\n  private _context: ConnectionContext;\n  /**\n   * The Id of the partition to which the batch is expected to be sent to.\n   * Specifying this will throw an error if the batch was created using a `partitionKey`.\n   */\n  private _partitionId?: string;\n  /**\n   * A value that is hashed to produce a partition assignment.\n   * It guarantees that messages with the same partitionKey end up in the same partition.\n   * Specifying this will throw an error if the batch was created using a `partitionId`.\n   */\n  private _partitionKey?: string;\n  /**\n   * The maximum size allowed for the batch.\n   */\n  private _maxSizeInBytes: number;\n  /**\n   * Current size of the batch in bytes.\n   */\n  private _sizeInBytes: number;\n  /**\n   * Encoded amqp messages.\n   */\n  private _encodedMessages: Buffer[] = [];\n  /**\n   * Number of events in the batch.\n   */\n  private _count: number;\n  /**\n   * List of 'message' span contexts.\n   */\n  private _spanContexts: TracingContext[] = [];\n  /**\n   * The message annotations to apply on the batch envelope.\n   * This will reflect the message annotations on the first event\n   * that was added to the batch.\n   * A common annotation is the partition key.\n   */\n  private _batchAnnotations?: MessageAnnotations;\n  /**\n   * Indicates that the batch should be treated as idempotent.\n   */\n  private _isIdempotent: boolean;\n  /**\n   * The sequence number assigned to the first event in the batch while\n   * the batch is being sent to the service.\n   */\n  private _pendingStartingSequenceNumber?: number;\n  /**\n   * The publishing sequence number assigned to the first event in the batch at the time\n   * the batch was successfully published.\n   * If the producer was not configured to apply sequence numbering or if the batch\n   * has not yet been successfully published, the value will be `undefined`.\n   */\n  private _startingPublishSequenceNumber?: number;\n\n  /**\n   * EventDataBatch should not be constructed using `new EventDataBatch()`\n   * Use the `createBatch()` method on your `EventHubProducer` instead.\n   * @internal\n   */\n  constructor(\n    context: ConnectionContext,\n    maxSizeInBytes: number,\n    isIdempotent: boolean,\n    partitionKey?: string,\n    partitionId?: string,\n  ) {\n    this._context = context;\n    this._maxSizeInBytes = maxSizeInBytes;\n    this._isIdempotent = isIdempotent;\n    this._partitionKey = isDefined(partitionKey) ? String(partitionKey) : partitionKey;\n    this._partitionId = isDefined(partitionId) ? String(partitionId) : partitionId;\n    this._sizeInBytes = 0;\n    this._count = 0;\n  }\n\n  /**\n   * The maximum size of the batch, in bytes.\n   * @readonly\n   */\n  get maxSizeInBytes(): number {\n    return this._maxSizeInBytes;\n  }\n\n  /**\n   * The partitionKey set during `EventDataBatch` creation. This value is hashed to\n   * produce a partition assignment when the producer is created without a `partitionId`\n   * @readonly\n   */\n  get partitionKey(): string | undefined {\n    return this._partitionKey;\n  }\n\n  /**\n   * The partitionId set during `EventDataBatch` creation.\n   * If this value is set then partitionKey can not be set.\n   * @readonly\n   */\n  get partitionId(): string | undefined {\n    return this._partitionId;\n  }\n\n  /**\n   * Size of the `EventDataBatch` instance after the events added to it have been\n   * encoded into a single AMQP message.\n   * @readonly\n   */\n  get sizeInBytes(): number {\n    return this._sizeInBytes;\n  }\n\n  /**\n   * Number of events in the `EventDataBatch` instance.\n   * @readonly\n   */\n  get count(): number {\n    return this._count;\n  }\n\n  /**\n   * The publishing sequence number assigned to the first event in the batch at the time\n   * the batch was successfully published.\n   * If the producer was not configured to apply sequence numbering or if the batch\n   * has not yet been successfully published, the value will be `undefined`.\n   */\n  get startingPublishedSequenceNumber(): number | undefined {\n    return this._startingPublishSequenceNumber;\n  }\n\n  /**\n   * Gets the \"message\" span contexts that were created when adding events to the batch.\n   * @internal\n   */\n  get _messageSpanContexts(): TracingContext[] {\n    return this._spanContexts;\n  }\n\n  /**\n   * Generates an AMQP message that contains the provided encoded events and annotations.\n   * @param encodedEvents - The already encoded events to include in the AMQP batch.\n   * @param annotations - The message annotations to set on the batch.\n   * @param publishingProps - Idempotent publishing properties used to decorate the events in the batch while sending.\n   */\n  private _generateBatch(\n    encodedEvents: Buffer[],\n    annotations: MessageAnnotations | undefined,\n    publishingProps?: PartitionPublishingProperties,\n  ): Buffer {\n    if (this._isIdempotent && publishingProps) {\n      // We need to decode the encoded events, add the idempotent annotations, and re-encode them.\n      // We can't lazily encode the events because we rely on `message.encode` to capture the\n      // byte length of anything not in `event.body`.\n      // Events can't be decorated ahead of time because the publishing properties aren't known\n      // until the events are being sent to the service.\n      const decodedEvents = encodedEvents.map(message.decode) as unknown as RheaMessage[];\n      const decoratedEvents = this._decorateRheaMessagesWithPublishingProps(\n        decodedEvents,\n        publishingProps,\n      );\n      encodedEvents = decoratedEvents.map(message.encode);\n    }\n\n    const batchEnvelope: RheaMessage = {\n      body: message.data_sections(encodedEvents),\n    };\n    if (annotations) {\n      batchEnvelope.message_annotations = annotations;\n    }\n    return message.encode(batchEnvelope);\n  }\n\n  /**\n   * Uses the publishingProps to add idempotent properties as message annotations to rhea messages.\n   */\n  private _decorateRheaMessagesWithPublishingProps(\n    events: RheaMessage[],\n    publishingProps: PartitionPublishingProperties,\n  ): RheaMessage[] {\n    if (!this._isIdempotent) {\n      return events;\n    }\n\n    const { lastPublishedSequenceNumber = 0, ownerLevel, producerGroupId } = publishingProps;\n    const startingSequenceNumber = lastPublishedSequenceNumber + 1;\n    for (let i = 0; i < events.length; i++) {\n      const event = events[i];\n      populateIdempotentMessageAnnotations(event, {\n        isIdempotentPublishingEnabled: this._isIdempotent,\n        ownerLevel,\n        producerGroupId,\n        publishSequenceNumber: startingSequenceNumber + i,\n      });\n    }\n\n    this._pendingStartingSequenceNumber = startingSequenceNumber;\n    return events;\n  }\n\n  /**\n   * Annotates a rhea message with placeholder idempotent properties if the batch is idempotent.\n   * This is necessary so that we can accurately calculate the size of the batch while adding events.\n   * Placeholder values are used because real values won't be known until we attempt to send the batch.\n   */\n  private _decorateRheaMessageWithPlaceholderIdempotencyProps(event: RheaMessage): RheaMessage {\n    if (!this._isIdempotent) {\n      return event;\n    }\n\n    if (!event.message_annotations) {\n      event.message_annotations = {};\n    }\n\n    // Set placeholder values for these annotations.\n    populateIdempotentMessageAnnotations(event, {\n      isIdempotentPublishingEnabled: this._isIdempotent,\n      ownerLevel: 0,\n      publishSequenceNumber: 0,\n      producerGroupId: 0,\n    });\n\n    return event;\n  }\n\n  /**\n   * Generates the single AMQP message which is the result of encoding all the events\n   * added into the `EventDataBatch` instance.\n   *\n   * This is not meant for the user to use directly.\n   *\n   * When the `EventDataBatch` instance is passed to the `send()` method on the `EventHubProducer`,\n   * this single batched AMQP message is what gets sent over the wire to the service.\n   * @readonly\n   */\n  _generateMessage(publishingProps?: PartitionPublishingProperties): Buffer {\n    return this._generateBatch(this._encodedMessages, this._batchAnnotations, publishingProps);\n  }\n\n  /**\n   * Sets startingPublishSequenceNumber to the pending publish sequence number.\n   */\n  _commitPublish(): void {\n    this._startingPublishSequenceNumber = this._pendingStartingSequenceNumber;\n  }\n\n  /**\n   * Tries to add an event data to the batch if permitted by the batch's size limit.\n   * **NOTE**: Always remember to check the return value of this method, before calling it again\n   * for the next event.\n   *\n   * @param eventData -  An individual event data object.\n   * @returns A boolean value indicating if the event data has been added to the batch or not.\n   */\n  public tryAdd(eventData: EventData | AmqpAnnotatedMessage, options: TryAddOptions = {}): boolean {\n    throwTypeErrorIfParameterMissing(this._context.connectionId, \"tryAdd\", \"eventData\", eventData);\n    if (!isAmqpAnnotatedMessage(eventData)) {\n      assertIsEventData(eventData);\n    }\n\n    const { entityPath, host } = this._context.config;\n    const { event: instrumentedEvent, spanContext } = instrumentEventData(\n      eventData,\n      options,\n      entityPath,\n      host,\n    );\n\n    // Convert EventData to RheaMessage.\n    const amqpMessage = toRheaMessage(instrumentedEvent, this._partitionKey);\n    const originalAnnotations = amqpMessage.message_annotations && {\n      ...amqpMessage.message_annotations,\n    };\n    this._decorateRheaMessageWithPlaceholderIdempotencyProps(amqpMessage);\n    const encodedMessage = message.encode(amqpMessage);\n\n    let currentSize = this._sizeInBytes;\n    // The first time an event is added, we need to calculate\n    // the overhead of creating an AMQP batch, including the\n    // message_annotations that are taken from the 1st message.\n    if (this.count === 0) {\n      if (originalAnnotations) {\n        this._batchAnnotations = originalAnnotations;\n      }\n\n      // Figure out the overhead of creating a batch by generating an empty batch\n      // with the expected batch annotations.\n      currentSize += this._generateBatch([], this._batchAnnotations).length;\n    }\n\n    const messageSize = encodedMessage.length;\n    const messageOverhead =\n      messageSize <= smallMessageMaxBytes ? smallMessageOverhead : largeMessageOverhead;\n    currentSize += messageSize + messageOverhead;\n\n    // Check if the size of the batch exceeds the maximum allowed size\n    // once we add the new event to it.\n    if (currentSize > this._maxSizeInBytes) {\n      return false;\n    }\n\n    // The event will fit in the batch, so it is now safe to store it.\n    this._encodedMessages.push(encodedMessage);\n    if (spanContext) {\n      this._spanContexts.push(spanContext);\n    }\n\n    this._sizeInBytes = currentSize;\n    this._count++;\n    return true;\n  }\n}\n"]}

package/dist/react-native/eventHubBufferedProducerClient.d.ts

@@ -0,0 +1,323 @@
+import type { EventData } from "./eventData.js";
+import type { OperationOptions } from "./util/operationOptions.js";
+import type { EventHubClientOptions, GetEventHubPropertiesOptions, GetPartitionIdsOptions, GetPartitionPropertiesOptions, SendBatchOptions } from "./models/public.js";
+import type { EventHubProperties, PartitionProperties } from "./managementClient.js";
+import type { NamedKeyCredential, SASCredential, TokenCredential } from "@azure/core-auth";
+import type { AmqpAnnotatedMessage } from "@azure/core-amqp";
+/**
+ * Contains the events that were successfully sent to the Event Hub,
+ * and the partition they were assigned to.
+ */
+export interface OnSendEventsSuccessContext {
+    /**
+     * The partition each event was assigned.
+     */
+    partitionId: string;
+    /**
+     * The array of {@link EventData} and/or `AmqpAnnotatedMessage` that were successfully sent to the Event Hub.
+     */
+    events: Array<EventData | AmqpAnnotatedMessage>;
+}
+/**
+ * Contains the events that were not successfully sent to the Event Hub,
+ * the partition they were assigned to, and the error that was encountered while sending.
+ */
+export interface OnSendEventsErrorContext {
+    /**
+     * The partition each event was assigned.
+     */
+    partitionId: string;
+    /**
+     * The array of {@link EventData} and/or `AmqpAnnotatedMessage` that were not successfully sent to the Event Hub.
+     */
+    events: Array<EventData | AmqpAnnotatedMessage>;
+    /**
+     * The error that occurred when sending the associated events to the Event Hub.
+     */
+    error: Error;
+}
+/**
+ * Describes the options that can be provided while creating the `EventHubBufferedProducerClient`.
+ */
+export interface EventHubBufferedProducerClientOptions extends EventHubClientOptions {
+    /**
+     * The total number of events that can be buffered for publishing at a given time for a given partition.
+     *
+     * Default: 1500
+     */
+    maxEventBufferLengthPerPartition?: number;
+    /**
+     * The amount of time to wait for a new event to be enqueued in the buffer before publishing a partially full batch.
+     *
+     * Default: 1 second.
+     */
+    maxWaitTimeInMs?: number;
+    /**
+     * The handler to call once a batch has successfully published.
+     */
+    onSendEventsSuccessHandler?: (ctx: OnSendEventsSuccessContext) => void;
+    /**
+     * The handler to call when a batch fails to publish.
+     */
+    onSendEventsErrorHandler: (ctx: OnSendEventsErrorContext) => void;
+    /**
+     * Indicates whether or not the EventHubProducerClient should enable idempotent publishing to Event Hub partitions.
+     * If enabled, the producer will only be able to publish directly to partitions;
+     * it will not be able to publish to the Event Hubs gateway for automatic partition routing
+     * nor will it be able to use a partition key.
+     * Default: false
+     */
+    enableIdempotentRetries?: boolean;
+}
+/**
+ * Options to configure the `flush` method on the `EventHubBufferedProducerClient`.
+ */
+export interface BufferedFlushOptions extends OperationOptions {
+}
+/**
+ * Options to configure the `close` method on the `EventHubBufferedProducerClient`.
+ */
+export interface BufferedCloseOptions extends OperationOptions {
+    /**
+     * When `true`, all buffered events that are pending should be sent before closing.
+     * When `false`, abandon all buffered events and close immediately.
+     * Defaults to `true`.
+     */
+    flush?: boolean;
+}
+/**
+ * Options to configure the `enqueueEvents` method on the `EventHubBufferedProducerClient`.
+ */
+export interface EnqueueEventOptions extends SendBatchOptions {
+}
+/**
+ * The `EventHubBufferedProducerClient`is used to publish events to a specific Event Hub.
+ *
+ * The `EventHubBufferedProducerClient` does not publish events immediately.
+ * Instead, events are buffered so they can be efficiently batched and published
+ * when the batch is full or the `maxWaitTimeInMs` has elapsed with no new events
+ * enqueued.
+ *
+ * Depending on the options specified when events are enqueued, they may be
+ * automatically assigned to a partition, grouped according to the specified partition key,
+ * or assigned a specifically requested partition.
+ *
+ * This model is intended to shift the burden of batch management from callers, at the cost of
+ * non-deterministic timing, for when events will be published. There are additional trade-offs
+ * to consider, as well:
+ * - If the application crashes, events in the buffer will not have been published. To prevent
+ *   data loss, callers are encouraged to track publishing progress using the
+ *   `onSendEventsSuccessHandler` and `onSendEventsErrorHandler` handlers.
+ * - Events specifying a partition key may be assigned a different partition than those using
+ *   the same key with other producers.
+ * - In the unlikely event that a partition becomes temporarily unavailable, the
+ *   `EventHubBufferedProducerClient` may take longer to recover than other producers.
+ *
+ * In scenarios where it is important to have events published immediately with a deterministic
+ * outcome, ensure that partition keys are assigned to a partition consistent with other
+ * publishers, or where maximizing availability is a requirement, using the
+ * `EventHubProducerClient` is recommended.
+ */
+export declare class EventHubBufferedProducerClient {
+    /**
+     * Controls the `abortSignal` passed to each `BatchingPartitionChannel`.
+     * Used to signal when a channel should stop waiting for events.
+     */
+    private _abortController;
+    /**
+     * Indicates whether the client has been explicitly closed.
+     */
+    private _isClosed;
+    /**
+     * Handles assigning partitions.
+     */
+    private _partitionAssigner;
+    /**
+     * The known partitionIds that will be used when assigning events to partitions.
+     */
+    private _partitionIds;
+    /**
+     * The EventHubProducerClient to use when creating and sending batches to the Event Hub.
+     */
+    private _producer;
+    /**
+     * Mapping of partitionIds to `BatchingPartitionChannels`.
+     * Each `BatchingPartitionChannel` handles buffering events and backpressure independently.
+     */
+    private _partitionChannels;
+    /**
+     * The options passed by the user when creating the EventHubBufferedProducerClient instance.
+     */
+    private _clientOptions;
+    /**
+     * The interval at which the background management operation should run.
+     */
+    private _backgroundManagementInterval;
+    /**
+     * Indicates whether the background management loop is running.
+     */
+    private _isBackgroundManagementRunning;
+    /**
+     * @readonly
+     * The name of the Event Hub instance for which this client is created.
+     */
+    get eventHubName(): string;
+    /**
+     * @readonly
+     * The fully qualified namespace of the Event Hub instance for which this client is created.
+     * This is likely to be similar to <yournamespace>.servicebus.windows.net.
+     */
+    get fullyQualifiedNamespace(): string;
+    /**
+     * The name used to identify this EventHubBufferedProducerClient.
+     * If not specified or empty, a random unique one will be generated.
+     */
+    readonly identifier: string;
+    /**
+     * The `EventHubBufferedProducerClient` class is used to send events to an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param connectionString - The connection string to use for connecting to the Event Hub instance.
+     * It is expected that the shared key properties and the Event Hub path are contained in this connection string.
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name'.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(connectionString: string, options: EventHubBufferedProducerClientOptions);
+    /**
+     * The `EventHubBufferedProducerClient` class is used to send events to an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param connectionString - The connection string to use for connecting to the Event Hubs namespace.
+     * It is expected that the shared key properties are contained in this connection string, but not the Event Hub path,
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;'.
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(connectionString: string, eventHubName: string, options: EventHubBufferedProducerClientOptions);
+    /**
+     * The `EventHubBufferedProducerClient` class is used to send events to an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param fullyQualifiedNamespace - The full namespace which is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param credential - An credential object used by the client to get the token to authenticate the connection
+     * with the Azure Event Hubs service.
+     * See &commat;azure/identity for creating credentials that support AAD auth.
+     * Use the `AzureNamedKeyCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessKeyName`
+     * and `SharedAccessKey` without using a connection string. These fields map to the `name` and `key` field respectively
+     * in `AzureNamedKeyCredential`.
+     * Use the `AzureSASCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessSignature`
+     * without using a connection string. This field maps to `signature` in `AzureSASCredential`.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(fullyQualifiedNamespace: string, eventHubName: string, credential: TokenCredential | NamedKeyCredential | SASCredential, options: EventHubBufferedProducerClientOptions);
+    /**
+     * Closes the AMQP connection to the Event Hub instance,
+     * returning a promise that will be resolved when disconnection is completed.
+     *
+     * This will wait for enqueued events to be flushed to the service before closing
+     * the connection.
+     * To close without flushing, set the `flush` option to `false`.
+     *
+     * @param options - The set of options to apply to the operation call.
+     * @returns Promise<void>
+     * @throws Error if the underlying connection encounters an error while closing.
+     */
+    close(options?: BufferedCloseOptions): Promise<void>;
+    /**
+     * Enqueues an event into the buffer to be published to the Event Hub.
+     * If there is no capacity in the buffer when this method is invoked,
+     * it will wait for space to become available and ensure that the event
+     * has been enqueued.
+     *
+     * When this call returns, the event has been accepted into the buffer,
+     * but it may not have been published yet.
+     * Publishing will take place at a nondeterministic point in the future as the buffer is processed.
+     *
+     * @param events - An {@link EventData} or `AmqpAnnotatedMessage`.
+     * @param options - A set of options that can be specified to influence the way in which
+     * the event is sent to the associated Event Hub.
+     * - `abortSignal`  : A signal used to cancel the enqueueEvent operation.
+     * - `partitionId`  : The partition this set of events will be sent to. If set, `partitionKey` can not be set.
+     * - `partitionKey` : A value that is hashed to produce a partition assignment. If set, `partitionId` can not be set.
+     * @returns The total number of events that are currently buffered and waiting to be published, across all partitions.
+     */
+    enqueueEvent(event: EventData | AmqpAnnotatedMessage, options?: EnqueueEventOptions): Promise<number>;
+    /**
+     * Enqueues events into the buffer to be published to the Event Hub.
+     * If there is no capacity in the buffer when this method is invoked,
+     * it will wait for space to become available and ensure that the events
+     * have been enqueued.
+     *
+     * When this call returns, the events have been accepted into the buffer,
+     * but it may not have been published yet.
+     * Publishing will take place at a nondeterministic point in the future as the buffer is processed.
+     *
+     * @param events - An array of {@link EventData} or `AmqpAnnotatedMessage`.
+     * @param options - A set of options that can be specified to influence the way in which
+     * events are sent to the associated Event Hub.
+     * - `abortSignal`  : A signal used to cancel the enqueueEvents operation.
+     * - `partitionId`  : The partition this set of events will be sent to. If set, `partitionKey` can not be set.
+     * - `partitionKey` : A value that is hashed to produce a partition assignment. If set, `partitionId` can not be set.
+     * @returns The total number of events that are currently buffered and waiting to be published, across all partitions.
+     */
+    enqueueEvents(events: EventData[] | AmqpAnnotatedMessage[], options?: EnqueueEventOptions): Promise<number>;
+    /**
+     * Attempts to publish all events in the buffer immediately.
+     * This may result in multiple batches being published,
+     * the outcome of each of which will be individually reported by
+     * the `onSendEventsSuccessHandler` and `onSendEventsErrorHandler` handlers.
+     *
+     * @param options - The set of options to apply to the operation call.
+     */
+    flush(options?: BufferedFlushOptions): Promise<void>;
+    /**
+     * Provides the Event Hub runtime information.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the Event Hub instance.
+     * @throws Error if the underlying connection has been closed, create a new EventHubBufferedProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getEventHubProperties(options?: GetEventHubPropertiesOptions): Promise<EventHubProperties>;
+    /**
+     * Provides the id for each partition associated with the Event Hub.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with an Array of strings representing the id for
+     * each partition associated with the Event Hub.
+     * @throws Error if the underlying connection has been closed, create a new EventHubBufferedProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionIds(options?: GetPartitionIdsOptions): Promise<Array<string>>;
+    /**
+     * Provides information about the state of the specified partition.
+     * @param partitionId - The id of the partition for which information is required.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the state of the partition .
+     * @throws Error if the underlying connection has been closed, create a new EventHubBufferedProducerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionProperties(partitionId: string, options?: GetPartitionPropertiesOptions): Promise<PartitionProperties>;
+    /**
+     * Gets the `BatchingPartitionChannel` associated with the partitionId.
+     *
+     * If one does not exist, it is created.
+     */
+    private _getPartitionChannel;
+    /**
+     * Returns the total number of buffered events across all partitions.
+     */
+    private _getTotalBufferedEventsCount;
+    private _updatePartitionIds;
+    private _startPartitionIdsUpdateLoop;
+}
+//# sourceMappingURL=eventHubBufferedProducerClient.d.ts.map