@azure/event-hubs 5.7.0-beta.1 → 5.7.0

package/types/latest/event-hubs.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="node" />
-
 import { AbortSignalLike } from '@azure/abort-controller';
 import { AmqpAnnotatedMessage } from '@azure/core-amqp';
-import { AzureLogger } from '@azure/logger';
 import { MessagingError } from '@azure/core-amqp';
 import { NamedKeyCredential } from '@azure/core-auth';
 import { OperationTracingOptions } from '@azure/core-tracing';
@@ -15,24 +13,6 @@ import { TokenCredential } from '@azure/core-auth';
 import { WebSocketImpl } from 'rhea-promise';
 import { WebSocketOptions } from '@azure/core-amqp';
 
-/**
- * Options to configure the `close` method on the `EventHubBufferedProducerClient`.
- */
-export declare 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 `flush` method on the `EventHubBufferedProducerClient`.
- */
-export declare interface BufferedFlushOptions extends OperationOptions {
-}
-
 /**
  * A checkpoint is meant to represent the last successfully processed event by the user from a particular
  * partition of a consumer group in an Event Hub instance.
@@ -188,12 +168,6 @@ export declare interface CreateBatchOptions extends OperationOptions {
  */
 export declare const earliestEventPosition: EventPosition;
 
-/**
- * Options to configure the `enqueueEvents` method on the `EventHubBufferedProcuerClient`.
- */
-export declare interface EnqueueEventOptions extends SendBatchOptions {
-}
-
 /**
  * The interface that describes the data to be sent to Event Hub.
  * Use this as a reference when creating the object to be sent when using the `EventHubProducerClient`.
@@ -284,248 +258,6 @@ export declare interface EventDataBatch {
     /* Excluded from this release type: _messageSpanContexts */
 }
 
-/**
- * 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;
-    /**
-     * @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 `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;
-}
-
-/**
- * Describes the options that can be provided while creating the `EventHubBufferedProducerClient`.
- */
-export declare 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) => Promise<void>;
-    /**
-     * The handler to call when a batch fails to publish.
-     */
-    onSendEventsErrorHandler: (ctx: OnSendEventsErrorContext) => Promise<void>;
-}
-
 /**
  * Describes the options that can be provided while creating the EventHubClient.
  * - `userAgent`        : A string to append to the built in user agent string that is passed as a connection property
@@ -1281,44 +1013,9 @@ export declare interface LoadBalancingOptions {
  * The `@azure/logger` configuration for this package.
  * This will output logs using the `azure:event-hubs` namespace prefix.
  */
-export declare const logger: AzureLogger;
-
+export declare const logger: import("@azure/logger").AzureLogger;
 export { MessagingError }
 
-/**
- * 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 declare 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;
-}
-
-/**
- * Contains the events that were successfully sent to the Event Hub,
- * and the partition they were assigned to.
- */
-export declare 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>;
-}
-
 /**
  * Options for configuring tracing and the abortSignal.
  */
@@ -1539,9 +1236,7 @@ export declare interface ReceivedEventData {
      */
     getRawAmqpMessage(): AmqpAnnotatedMessage;
 }
-
 export { RetryMode }
-
 export { RetryOptions }
 
 /**
@@ -1592,7 +1287,7 @@ export declare interface SubscribeOptions {
     /**
      * Indicates whether or not the consumer should request information on the last enqueued event on its
      * associated partition, and track that information as events are received.
-
+  
      * When information about the partition's last enqueued event is being tracked, each event received
      * from the Event Hubs service will carry metadata about the partition that it otherwise would not. This results in a small amount of
      * additional network bandwidth consumption that is generally a favorable trade-off when considered
@@ -1694,7 +1389,6 @@ export declare interface SubscriptionEventHandlers {
      */
     processClose?: ProcessCloseHandler;
 }
-
 export { TokenCredential }
 
 /**
@@ -1710,9 +1404,7 @@ export declare interface TryAddOptions {
      */
     parentSpan?: Span | SpanContext;
 }
-
 export { WebSocketImpl }
-
 export { WebSocketOptions }
 
 export { }

package/types/latest/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.18.19"
+      "packageVersion": "7.7.11"
     }
   ]
 }

package/dist-esm/src/batchingPartitionChannel.js

@@ -1,241 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-import { delay } from "@azure/core-amqp";
-import { AwaitableQueue } from "./impl/awaitableQueue";
-import { isDefined, isObjectWithProperties } from "./util/typeGuards";
-import { getPromiseParts } from "./util/getPromiseParts";
-import { logger } from "./log";
-/**
- * The `BatchingPartitionChannel` is responsible for accepting enqueued events
- * and optimally batching and sending them to an Event Hub.
- * @internal
- */
-export class BatchingPartitionChannel {
-    constructor({ loopAbortSignal, maxBufferSize, maxWaitTimeInMs, onSendEventsErrorHandler, onSendEventsSuccessHandler, partitionId, producer }) {
-        this._eventQueue = new AwaitableQueue();
-        this._batchedEvents = [];
-        this._bufferCount = 0;
-        this._readyQueue = [];
-        this._flushState = {
-            isFlushing: false
-        };
-        this._isRunning = false;
-        this._lastBatchCreationTime = 0;
-        this._loopAbortSignal = loopAbortSignal;
-        this._maxBufferSize = maxBufferSize;
-        this._maxWaitTimeInMs = maxWaitTimeInMs;
-        this._onSendEventsErrorHandler = onSendEventsErrorHandler;
-        this._onSendEventsSuccessHandler = onSendEventsSuccessHandler;
-        this._partitionId = partitionId;
-        this._producer = producer;
-    }
-    getCurrentBufferedCount() {
-        return this._bufferCount;
-    }
-    async enqueueEvent(event) {
-        await this._ready();
-        this._eventQueue.push(event);
-        this._bufferCount++;
-        if (!this._isRunning) {
-            this._isRunning = true;
-            this._startPublishLoop().catch((e) => {
-                logger.error(`The following error occured during batch creation or sending: ${JSON.stringify(e, undefined, "  ")}`);
-            });
-        }
-    }
-    /**
-     * Sets the flush state so that no new events can be enqueued until
-     * all the currently buffered events are sent to the Event Hub.
-     *
-     * Returns a promise that resolves once flushing is complete.
-     */
-    async flush(_options = {}) {
-        const state = this._flushState;
-        if (state.isFlushing) {
-            return state.currentPromise;
-        }
-        if (this.getCurrentBufferedCount() === 0) {
-            return Promise.resolve();
-        }
-        const { promise, resolve } = getPromiseParts();
-        this._flushState = { isFlushing: true, currentPromise: promise, resolve };
-        return promise;
-    }
-    /**
-     * Returns a promise that resolves once there is room for events to be added
-     * to the buffer.
-     */
-    _ready() {
-        const currentBufferedCount = this.getCurrentBufferedCount();
-        // If the buffer isn't full and we don't have any pending `ready()` calls,
-        // then it's safe to return right away.
-        if (currentBufferedCount < this._maxBufferSize &&
-            !this._readyQueue.length &&
-            !this._flushState.isFlushing) {
-            return Promise.resolve();
-        }
-        const { promise: readyPromise, reject, resolve } = getPromiseParts();
-        this._readyQueue.push({ resolve, reject });
-        return readyPromise;
-    }
-    /**
-     * Starts the loop that creates batches and sends them to the Event Hub.
-     *
-     * The loop will run until the `_loopAbortSignal` is aborted.
-     */
-    async _startPublishLoop() {
-        let batch;
-        let futureEvent = this._eventQueue.shift();
-        // `eventToAddToBatch` is used to keep track of an event that has been removed
-        // from the queue, but has not yet been added to a batch.
-        // This prevents losing an event if a `sendBatch` or `createBatch` call fails
-        // before the event is added to a batch.
-        let eventToAddToBatch;
-        while (!this._loopAbortSignal.aborted) {
-            try {
-                if (!isDefined(batch)) {
-                    batch = await this._createBatch();
-                }
-                const timeSinceLastBatchCreation = Date.now() - this._lastBatchCreationTime;
-                const maximumTimeToWaitForEvent = batch.count
-                    ? Math.max(this._maxWaitTimeInMs - timeSinceLastBatchCreation, 0)
-                    : this._maxWaitTimeInMs;
-                const event = eventToAddToBatch !== null && eventToAddToBatch !== void 0 ? eventToAddToBatch : (await Promise.race([futureEvent, delay(maximumTimeToWaitForEvent)]));
-                if (!event) {
-                    // We didn't receive an event within the allotted time.
-                    // Send the existing batch if it has events in it.
-                    if (batch.count) {
-                        await this._producer.sendBatch(batch);
-                        this._reportSuccess();
-                        batch = await this._createBatch();
-                    }
-                    continue;
-                }
-                else if (!eventToAddToBatch) {
-                    eventToAddToBatch = event;
-                    // We received an event, so get a promise for the next one.
-                    futureEvent = this._eventQueue.shift();
-                }
-                const didAdd = batch.tryAdd(event);
-                if (didAdd) {
-                    // This event will definitely make it to one of the user-provided handlers
-                    // since it was added to a batch.
-                    // Store it so we can return it in a handler later.
-                    this._batchedEvents.push(event);
-                    // Clear reference to existing event since it has been added to the batch.
-                    eventToAddToBatch = undefined;
-                }
-                if (didAdd && batch.count >= this._maxBufferSize) {
-                    // Whenever batch.count exceeds the max count of buffered events, send the batch.
-                    await this._producer.sendBatch(batch);
-                    this._reportSuccess();
-                    batch = await this._createBatch();
-                }
-                else if (!didAdd && batch.count) {
-                    // If the event wasn't able to be added and the current batch isn't empty,
-                    // attempt to send the current batch and add the event to a new batch.
-                    await this._producer.sendBatch(batch);
-                    this._reportSuccess();
-                    batch = await this._createBatch();
-                }
-                if (!didAdd && !batch.tryAdd(event)) {
-                    // TODO: Report MaxMesageSizeExceeded error. Mimic service's error.
-                    this._reportFailure(new Error("Placeholder for max message size exceeded"), event);
-                }
-                else if (!didAdd) {
-                    // Handles the case where the event _was_ successfull added to the new batch.
-                    this._batchedEvents.push(event);
-                }
-                // Clear reference to existing event since it has been added to the batch.
-                eventToAddToBatch = undefined;
-            }
-            catch (err) {
-                if (!isObjectWithProperties(err, ["name"]) || err.name !== "AbortError") {
-                    this._reportFailure(err);
-                    batch = undefined;
-                    this._batchedEvents = [];
-                }
-            }
-        }
-    }
-    /**
-     * Helper method that returns an `EventDataBatch`.
-     * This also has the side effects of
-     *  - keeping track of batch creation time: needed for maxWaitTime calculations.
-     *  - clearing reference to batched events.
-     *  - incrementing the readiness: creating a new batch indicates the buffer
-     *    should have room, so we can resolve some pending `ready()` calls.
-     */
-    async _createBatch() {
-        this._lastBatchCreationTime = Date.now();
-        this._batchedEvents = [];
-        const batch = await this._producer.createBatch({
-            partitionId: this._partitionId
-        });
-        this._incrementReadiness();
-        return batch;
-    }
-    /**
-     * This method will resolve as many pending `ready()` calls as it can
-     * based on how much space remains in the buffer.
-     *
-     * If the channel is currently flushing, this is a no-op. This prevents
-     * `enqueueEvent` calls from adding the event to the buffer until flushing
-     * completes.
-     */
-    _incrementReadiness() {
-        var _a;
-        if (this._flushState.isFlushing) {
-            return;
-        }
-        const currentBufferedCount = this.getCurrentBufferedCount();
-        const num = Math.min(this._maxBufferSize - currentBufferedCount, this._readyQueue.length);
-        for (let i = 0; i < num; i++) {
-            (_a = this._readyQueue.shift()) === null || _a === void 0 ? void 0 : _a.resolve();
-        }
-    }
-    /**
-     * Calls the user-provided `onSendEventsSuccessHandler` with the events
-     * that were successfully sent.
-     */
-    _reportSuccess() {
-        var _a;
-        this._bufferCount = this._bufferCount - this._batchedEvents.length;
-        this._updateFlushState();
-        (_a = this._onSendEventsSuccessHandler) === null || _a === void 0 ? void 0 : _a.call(this, {
-            events: this._batchedEvents,
-            partitionId: this._partitionId
-        }).catch((e) => {
-            logger.error(`The following error occured in the onSendEventsSuccessHandler: ${JSON.stringify(e, undefined, "  ")}`);
-        });
-    }
-    /**
-     * Calls the user-provided `onSendEventsErrorHandler` with an error and the events
-     * that were not successfully sent.
-     */
-    _reportFailure(err, event) {
-        this._bufferCount = this._bufferCount - (event ? 1 : this._batchedEvents.length);
-        this._updateFlushState();
-        this._onSendEventsErrorHandler({
-            error: err,
-            events: event ? [event] : this._batchedEvents,
-            partitionId: this._partitionId
-        }).catch((e) => {
-            logger.error(`The following error occured in the onSendEventsErrorHandler: ${JSON.stringify(e, undefined, "  ")}`);
-        });
-    }
-    /**
-     * Updates the channel's flush state once the size of the
-     * event buffer has decreased to 0.
-     */
-    _updateFlushState() {
-        const state = this._flushState;
-        if (!state.isFlushing || this.getCurrentBufferedCount() !== 0) {
-            return;
-        }
-        state.resolve();
-        this._flushState = { isFlushing: false };
-        this._incrementReadiness();
-    }
-}
-//# sourceMappingURL=batchingPartitionChannel.js.map

package/dist-esm/src/batchingPartitionChannel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchingPartitionChannel.js","sourceRoot":"","sources":["../../src/batchingPartitionChannel.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport { AmqpAnnotatedMessage, delay } from \"@azure/core-amqp\";\nimport {\n  EventData,\n  EventDataBatch,\n  EventHubBufferedProducerClientOptions,\n  EventHubProducerClient,\n  OperationOptions\n} from \"./index\";\nimport { AwaitableQueue } from \"./impl/awaitableQueue\";\nimport { isDefined, isObjectWithProperties } from \"./util/typeGuards\";\nimport { AbortSignalLike } from \"@azure/abort-controller\";\nimport { getPromiseParts } from \"./util/getPromiseParts\";\nimport { logger } from \"./log\";\n\nexport interface BatchingPartitionChannelProps {\n  loopAbortSignal: AbortSignalLike;\n  maxBufferSize: number;\n  maxWaitTimeInMs: number;\n  partitionId: string;\n  producer: EventHubProducerClient;\n  /**\n   * The handler to call once a batch has successfully published.\n   */\n  onSendEventsSuccessHandler?: EventHubBufferedProducerClientOptions[\"onSendEventsSuccessHandler\"];\n  /**\n   * The handler to call when a batch fails to publish.\n   */\n  onSendEventsErrorHandler: EventHubBufferedProducerClientOptions[\"onSendEventsErrorHandler\"];\n}\n\n/**\n * The `BatchingPartitionChannel` is responsible for accepting enqueued events\n * and optimally batching and sending them to an Event Hub.\n * @internal\n */\nexport class BatchingPartitionChannel {\n  private _eventQueue = new AwaitableQueue<EventData | AmqpAnnotatedMessage>();\n  private _batchedEvents: Array<EventData | AmqpAnnotatedMessage> = [];\n  private _bufferCount: number = 0;\n  private _readyQueue: Array<{\n    resolve: (value: void) => void;\n    reject: (reason?: any) => void;\n  }> = [];\n  private _flushState:\n    | { isFlushing: false }\n    | { isFlushing: true; currentPromise: Promise<void>; resolve: () => void } = {\n    isFlushing: false\n  };\n  private _isRunning: boolean = false;\n  private _lastBatchCreationTime: number = 0;\n  private _loopAbortSignal: AbortSignalLike;\n  private _maxBufferSize: number;\n  private _maxWaitTimeInMs: number;\n  private _onSendEventsErrorHandler: EventHubBufferedProducerClientOptions[\"onSendEventsErrorHandler\"];\n  private _onSendEventsSuccessHandler?: EventHubBufferedProducerClientOptions[\"onSendEventsSuccessHandler\"];\n\n  private _partitionId: string;\n  private _producer: EventHubProducerClient;\n\n  constructor({\n    loopAbortSignal,\n    maxBufferSize,\n    maxWaitTimeInMs,\n    onSendEventsErrorHandler,\n    onSendEventsSuccessHandler,\n    partitionId,\n    producer\n  }: BatchingPartitionChannelProps) {\n    this._loopAbortSignal = loopAbortSignal;\n    this._maxBufferSize = maxBufferSize;\n    this._maxWaitTimeInMs = maxWaitTimeInMs;\n    this._onSendEventsErrorHandler = onSendEventsErrorHandler;\n    this._onSendEventsSuccessHandler = onSendEventsSuccessHandler;\n    this._partitionId = partitionId;\n    this._producer = producer;\n  }\n\n  getCurrentBufferedCount(): number {\n    return this._bufferCount;\n  }\n\n  async enqueueEvent(event: EventData | AmqpAnnotatedMessage): Promise<void> {\n    await this._ready();\n    this._eventQueue.push(event);\n    this._bufferCount++;\n\n    if (!this._isRunning) {\n      this._isRunning = true;\n      this._startPublishLoop().catch((e) => {\n        logger.error(\n          `The following error occured during batch creation or sending: ${JSON.stringify(\n            e,\n            undefined,\n            \"  \"\n          )}`\n        );\n      });\n    }\n  }\n\n  /**\n   * Sets the flush state so that no new events can be enqueued until\n   * all the currently buffered events are sent to the Event Hub.\n   *\n   * Returns a promise that resolves once flushing is complete.\n   */\n  async flush(_options: OperationOptions = {}): Promise<void> {\n    const state = this._flushState;\n    if (state.isFlushing) {\n      return state.currentPromise;\n    }\n\n    if (this.getCurrentBufferedCount() === 0) {\n      return Promise.resolve();\n    }\n\n    const { promise, resolve } = getPromiseParts<void>();\n    this._flushState = { isFlushing: true, currentPromise: promise, resolve };\n\n    return promise;\n  }\n\n  /**\n   * Returns a promise that resolves once there is room for events to be added\n   * to the buffer.\n   */\n  private _ready(): Promise<void> {\n    const currentBufferedCount = this.getCurrentBufferedCount();\n\n    // If the buffer isn't full and we don't have any pending `ready()` calls,\n    // then it's safe to return right away.\n    if (\n      currentBufferedCount < this._maxBufferSize &&\n      !this._readyQueue.length &&\n      !this._flushState.isFlushing\n    ) {\n      return Promise.resolve();\n    }\n\n    const { promise: readyPromise, reject, resolve } = getPromiseParts<void>();\n    this._readyQueue.push({ resolve, reject });\n\n    return readyPromise;\n  }\n\n  /**\n   * Starts the loop that creates batches and sends them to the Event Hub.\n   *\n   * The loop will run until the `_loopAbortSignal` is aborted.\n   */\n  private async _startPublishLoop() {\n    let batch: EventDataBatch | undefined;\n    let futureEvent = this._eventQueue.shift();\n    // `eventToAddToBatch` is used to keep track of an event that has been removed\n    // from the queue, but has not yet been added to a batch.\n    // This prevents losing an event if a `sendBatch` or `createBatch` call fails\n    // before the event is added to a batch.\n    let eventToAddToBatch: EventData | AmqpAnnotatedMessage | undefined;\n    while (!this._loopAbortSignal.aborted) {\n      try {\n        if (!isDefined(batch)) {\n          batch = await this._createBatch();\n        }\n        const timeSinceLastBatchCreation = Date.now() - this._lastBatchCreationTime;\n        const maximumTimeToWaitForEvent = batch.count\n          ? Math.max(this._maxWaitTimeInMs - timeSinceLastBatchCreation, 0)\n          : this._maxWaitTimeInMs;\n\n        const event =\n          eventToAddToBatch ??\n          (await Promise.race([futureEvent, delay<void>(maximumTimeToWaitForEvent)]));\n\n        if (!event) {\n          // We didn't receive an event within the allotted time.\n          // Send the existing batch if it has events in it.\n          if (batch.count) {\n            await this._producer.sendBatch(batch);\n            this._reportSuccess();\n            batch = await this._createBatch();\n          }\n          continue;\n        } else if (!eventToAddToBatch) {\n          eventToAddToBatch = event;\n          // We received an event, so get a promise for the next one.\n          futureEvent = this._eventQueue.shift();\n        }\n\n        const didAdd = batch.tryAdd(event);\n        if (didAdd) {\n          // This event will definitely make it to one of the user-provided handlers\n          // since it was added to a batch.\n          // Store it so we can return it in a handler later.\n          this._batchedEvents.push(event);\n          // Clear reference to existing event since it has been added to the batch.\n          eventToAddToBatch = undefined;\n        }\n\n        if (didAdd && batch.count >= this._maxBufferSize) {\n          // Whenever batch.count exceeds the max count of buffered events, send the batch.\n          await this._producer.sendBatch(batch);\n          this._reportSuccess();\n          batch = await this._createBatch();\n        } else if (!didAdd && batch.count) {\n          // If the event wasn't able to be added and the current batch isn't empty,\n          // attempt to send the current batch and add the event to a new batch.\n          await this._producer.sendBatch(batch);\n          this._reportSuccess();\n          batch = await this._createBatch();\n        }\n\n        if (!didAdd && !batch.tryAdd(event)) {\n          // TODO: Report MaxMesageSizeExceeded error. Mimic service's error.\n          this._reportFailure(new Error(\"Placeholder for max message size exceeded\"), event);\n        } else if (!didAdd) {\n          // Handles the case where the event _was_ successfull added to the new batch.\n          this._batchedEvents.push(event);\n        }\n        // Clear reference to existing event since it has been added to the batch.\n        eventToAddToBatch = undefined;\n      } catch (err) {\n        if (!isObjectWithProperties(err, [\"name\"]) || err.name !== \"AbortError\") {\n          this._reportFailure(err);\n          batch = undefined;\n          this._batchedEvents = [];\n        }\n      }\n    }\n  }\n\n  /**\n   * Helper method that returns an `EventDataBatch`.\n   * This also has the side effects of\n   *  - keeping track of batch creation time: needed for maxWaitTime calculations.\n   *  - clearing reference to batched events.\n   *  - incrementing the readiness: creating a new batch indicates the buffer\n   *    should have room, so we can resolve some pending `ready()` calls.\n   */\n  private async _createBatch(): Promise<EventDataBatch> {\n    this._lastBatchCreationTime = Date.now();\n    this._batchedEvents = [];\n    const batch = await this._producer.createBatch({\n      partitionId: this._partitionId\n    });\n    this._incrementReadiness();\n    return batch;\n  }\n\n  /**\n   * This method will resolve as many pending `ready()` calls as it can\n   * based on how much space remains in the buffer.\n   *\n   * If the channel is currently flushing, this is a no-op. This prevents\n   * `enqueueEvent` calls from adding the event to the buffer until flushing\n   * completes.\n   */\n  private _incrementReadiness() {\n    if (this._flushState.isFlushing) {\n      return;\n    }\n    const currentBufferedCount = this.getCurrentBufferedCount();\n    const num = Math.min(this._maxBufferSize - currentBufferedCount, this._readyQueue.length);\n    for (let i = 0; i < num; i++) {\n      this._readyQueue.shift()?.resolve();\n    }\n  }\n\n  /**\n   * Calls the user-provided `onSendEventsSuccessHandler` with the events\n   * that were successfully sent.\n   */\n  private _reportSuccess() {\n    this._bufferCount = this._bufferCount - this._batchedEvents.length;\n    this._updateFlushState();\n    this._onSendEventsSuccessHandler?.({\n      events: this._batchedEvents,\n      partitionId: this._partitionId\n    }).catch((e) => {\n      logger.error(\n        `The following error occured in the onSendEventsSuccessHandler: ${JSON.stringify(\n          e,\n          undefined,\n          \"  \"\n        )}`\n      );\n    });\n  }\n\n  /**\n   * Calls the user-provided `onSendEventsErrorHandler` with an error and the events\n   * that were not successfully sent.\n   */\n  private _reportFailure(err: any, event?: EventData | AmqpAnnotatedMessage) {\n    this._bufferCount = this._bufferCount - (event ? 1 : this._batchedEvents.length);\n    this._updateFlushState();\n    this._onSendEventsErrorHandler({\n      error: err,\n      events: event ? [event] : this._batchedEvents,\n      partitionId: this._partitionId\n    }).catch((e) => {\n      logger.error(\n        `The following error occured in the onSendEventsErrorHandler: ${JSON.stringify(\n          e,\n          undefined,\n          \"  \"\n        )}`\n      );\n    });\n  }\n\n  /**\n   * Updates the channel's flush state once the size of the\n   * event buffer has decreased to 0.\n   */\n  private _updateFlushState() {\n    const state = this._flushState;\n    if (!state.isFlushing || this.getCurrentBufferedCount() !== 0) {\n      return;\n    }\n\n    state.resolve();\n\n    this._flushState = { isFlushing: false };\n    this._incrementReadiness();\n  }\n}\n"]}