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

package/dist/index.js

@@ -7,7 +7,6 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 var logger$1 = require('@azure/logger');
 var coreAuth = require('@azure/core-auth');
 var os = require('os');
-var os__default = _interopDefault(os);
 var coreAmqp = require('@azure/core-amqp');
 var uuid = require('uuid');
 var rheaPromise = require('rhea-promise');
@@ -93,7 +92,7 @@ function getRuntimeInfo() {
  */
 const packageJsonInfo = {
     name: "@azure/event-hubs",
-    version: "5.7.0-beta.1"
+    version: "5.7.0"
 };
 
 // Copyright (c) Microsoft Corporation.
@@ -2186,43 +2185,26 @@ const TRACEPARENT_PROPERTY = "Diagnostic-Id";
  * @param eventData - The `EventData` or `AmqpAnnotatedMessage` to instrument.
  * @param span - The `Span` containing the context to propagate tracing information.
  */
-function instrumentEventData(eventData, options, entityPath, host) {
+function instrumentEventData(eventData, span) {
     const props = isAmqpAnnotatedMessage(eventData)
         ? eventData.applicationProperties
         : eventData.properties;
-    // check if the event has already been instrumented
-    const previouslyInstrumented = Boolean(props === null || props === void 0 ? void 0 : props[TRACEPARENT_PROPERTY]);
-    if (previouslyInstrumented) {
-        return { event: eventData, spanContext: undefined };
+    if (props && props[TRACEPARENT_PROPERTY]) {
+        return eventData;
     }
-    const { span: messageSpan } = createMessageSpan(options, { entityPath, host });
-    try {
-        if (!messageSpan.isRecording()) {
-            return {
-                event: eventData,
-                spanContext: undefined
-            };
-        }
-        const traceParent = coreTracing.getTraceParentHeader(messageSpan.spanContext());
-        if (traceParent && coreTracing.isSpanContextValid(messageSpan.spanContext())) {
-            const copiedProps = Object.assign({}, props);
-            // create a copy so the original isn't modified
-            if (isAmqpAnnotatedMessage(eventData)) {
-                eventData = Object.assign(Object.assign({}, eventData), { applicationProperties: copiedProps });
-            }
-            else {
-                eventData = Object.assign(Object.assign({}, eventData), { properties: copiedProps });
-            }
-            copiedProps[TRACEPARENT_PROPERTY] = traceParent;
-        }
-        return {
-            event: eventData,
-            spanContext: messageSpan.spanContext()
-        };
+    const copiedProps = Object.assign({}, props);
+    // create a copy so the original isn't modified
+    if (isAmqpAnnotatedMessage(eventData)) {
+        eventData = Object.assign(Object.assign({}, eventData), { applicationProperties: copiedProps });
     }
-    finally {
-        messageSpan.end();
+    else {
+        eventData = Object.assign(Object.assign({}, eventData), { properties: copiedProps });
+    }
+    const traceParent = coreTracing.getTraceParentHeader(span.spanContext());
+    if (traceParent) {
+        copiedProps[TRACEPARENT_PROPERTY] = traceParent;
     }
+    return eventData;
 }
 /**
  * Extracts the `SpanContext` from an `EventData` if the context exists.
@@ -3839,12 +3821,23 @@ class EventDataBatchImpl {
      * @returns A boolean value indicating if the event data has been added to the batch or not.
      */
     tryAdd(eventData, options = {}) {
+        var _a;
         throwTypeErrorIfParameterMissing(this._context.connectionId, "tryAdd", "eventData", eventData);
         options = convertTryAddOptionsForCompatibility(options);
-        const { entityPath, host } = this._context.config;
-        const { event: instrumentedEvent, spanContext } = instrumentEventData(eventData, options, entityPath, host);
+        // check if the event has already been instrumented
+        const previouslyInstrumented = Boolean((_a = (isAmqpAnnotatedMessage(eventData)
+            ? eventData.applicationProperties
+            : eventData.properties)) === null || _a === void 0 ? void 0 : _a[TRACEPARENT_PROPERTY] // Event Data maps properties to applicationProperties.
+        );
+        let spanContext;
+        if (!previouslyInstrumented) {
+            const { span: messageSpan } = createMessageSpan(options, this._context.config);
+            eventData = instrumentEventData(eventData, messageSpan);
+            spanContext = messageSpan.spanContext();
+            messageSpan.end();
+        }
         // Convert EventData to RheaMessage.
-        const amqpMessage = toRheaMessage(instrumentedEvent, this._partitionKey);
+        const amqpMessage = toRheaMessage(eventData, this._partitionKey);
         const encodedMessage = rheaPromise.message.encode(amqpMessage);
         let currentSize = this._sizeInBytes;
         // The first time an event is added, we need to calculate
@@ -4354,7 +4347,15 @@ class EventHubProducerClient {
             partitionId = expectedOptions.partitionId;
             partitionKey = expectedOptions.partitionKey;
             for (let i = 0; i < batch.length; i++) {
-                batch[i] = instrumentEventData(batch[i], options, this._context.config.entityPath, this._context.config.host).event;
+                const event = batch[i];
+                if (!event.properties || !event.properties[TRACEPARENT_PROPERTY]) {
+                    const { span: messageSpan } = createMessageSpan(options, this._context.config);
+                    // since these message spans are created from same context as the send span,
+                    // these message spans don't need to be linked.
+                    // replace the original event with the instrumented one
+                    batch[i] = instrumentEventData(batch[i], messageSpan);
+                    messageSpan.end();
+                }
             }
         }
         if (isDefined(partitionId) && isDefined(partitionKey)) {
@@ -4452,697 +4453,6 @@ class EventHubProducerClient {
     }
 }
 
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-/**
- * `AwaitableQueue` stores items in the order that they are received.
- *
- * This differs from ordinary Queues in that `shift` returns a Promise for a value.
- * This allows a consumer of the queue to request an item that the queue does not yet have.
- *
- * @hidden
- */
-class AwaitableQueue {
-    constructor() {
-        this._resolvers = [];
-        this._items = [];
-    }
-    size() {
-        return this._items.length;
-    }
-    /**
-     * Returns a Promise that will resolve with the next item in the queue.
-     */
-    shift() {
-        const item = this._items.shift();
-        if (typeof item !== "undefined") {
-            return Promise.resolve(item);
-        }
-        return new Promise((resolve) => this._resolvers.push(resolve));
-    }
-    /**
-     * Appends new item to the queue.
-     */
-    push(item) {
-        if (!this._resolveNextItem(item)) {
-            this._items.push(item);
-        }
-    }
-    _resolveNextItem(item) {
-        const resolver = this._resolvers.shift();
-        if (!resolver) {
-            return false;
-        }
-        resolver(item);
-        return true;
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-/**
- * @internal
- * Returns a promise and the promise's resolve and reject methods.
- */
-function getPromiseParts() {
-    let resolver;
-    let rejector;
-    const promise = new Promise((resolve, reject) => {
-        resolver = resolve;
-        rejector = reject;
-    });
-    return {
-        promise,
-        resolve: resolver,
-        reject: rejector
-    };
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * The `BatchingPartitionChannel` is responsible for accepting enqueued events
- * and optimally batching and sending them to an Event Hub.
- * @internal
- */
-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, coreAmqp.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();
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-function mapPartitionKeyToId(partitionKey, partitionCount) {
-    const hash = computeHash(Buffer.from(partitionKey, "utf8"));
-    const hashedParitionKey = castToInt16(hash.c ^ hash.b);
-    return Math.abs(hashedParitionKey % partitionCount);
-}
-function readUInt32(data, offset) {
-    return os__default.endianness() === "BE" ? data.readUInt32BE(offset) : data.readUInt32LE(offset);
-}
-function castToInt16(n) {
-    return new Int16Array([n])[0];
-}
-function computeHash(data, seed1 = 0, seed2 = 0) {
-    let a, b, c;
-    a = b = c = 0xdeadbeef + data.length + seed1;
-    c += seed2;
-    let index = 0, size = data.length;
-    while (size > 12) {
-        a += readUInt32(data, index);
-        b += readUInt32(data, index + 4);
-        c += readUInt32(data, index + 8);
-        a -= c;
-        a ^= (c << 4) | (c >>> 28);
-        c += b;
-        b -= a;
-        b ^= (a << 6) | (a >>> 26);
-        a += c;
-        c -= b;
-        c ^= (b << 8) | (b >>> 24);
-        b += a;
-        a -= c;
-        a ^= (c << 16) | (c >>> 16);
-        c += b;
-        b -= a;
-        b ^= (a << 19) | (a >>> 13);
-        a += c;
-        c -= b;
-        c ^= (b << 4) | (b >>> 28);
-        b += a;
-        index += 12;
-        size -= 12;
-    }
-    let curr = size;
-    switch (curr) {
-        case 12:
-            a += readUInt32(data, index);
-            b += readUInt32(data, index + 4);
-            c += readUInt32(data, index + 8);
-            break;
-        case 11:
-            c += data[index + 10] << 16;
-            curr = 10;
-        case 10:
-            c += data[index + 9] << 8;
-            curr = 9;
-        case 9:
-            c += data[index + 8];
-            curr = 8;
-        case 8:
-            b += readUInt32(data, index + 4);
-            a += readUInt32(data, index);
-            break;
-        case 7:
-            b += data[index + 6] << 16;
-            curr = 6;
-        case 6:
-            b += data[index + 5] << 8;
-            curr = 5;
-        case 5:
-            b += data[index + 4];
-            curr = 4;
-        case 4:
-            a += readUInt32(data, index);
-            break;
-        case 3:
-            a += data[index + 2] << 16;
-            curr = 2;
-        case 2:
-            a += data[index + 1] << 8;
-            curr = 1;
-        case 1:
-            a += data[index];
-            break;
-        case 0:
-            return { b: b >>> 0, c: c >>> 0 };
-    }
-    c ^= b;
-    c -= (b << 14) | (b >>> 18);
-    a ^= c;
-    a -= (c << 11) | (c >>> 21);
-    b ^= a;
-    b -= (a << 25) | (a >>> 7);
-    c ^= b;
-    c -= (b << 16) | (b >>> 16);
-    a ^= c;
-    a -= (c << 4) | (c >>> 28);
-    b ^= a;
-    b -= (a << 14) | (a >>> 18);
-    c ^= b;
-    c -= (b << 24) | (b >>> 8);
-    return { b: b >>> 0, c: c >>> 0 };
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * @internal
- * Assigns a partition based on the partition ids it knows about and an optional partition id or partition key.
- */
-class PartitionAssigner {
-    constructor() {
-        this._partitions = [];
-        this._lastRoundRobinPartitionIndex = -1;
-    }
-    /**
-     * Set the partition ids that can be used when assigning a partition.
-     * @param partitionIds - All valid partition ids.
-     */
-    setPartitionIds(partitionIds) {
-        this._partitions = partitionIds;
-    }
-    /**
-     * Returns a partitionId from the list of partition ids set via `setPartitionIds`.
-     *
-     * If a partitionId is specified, then that will be returned directly.
-     * If a partitionKey is specified, then a partitionId will be calculated based on the partitionKey.
-     * Specifying both partitionId and partitionKey results in an error.
-     *
-     * If neither partitionId nor partitionKey are specified, then a partitionId will be selected
-     * based on a round-robin approach.
-     */
-    assignPartition({ partitionId, partitionKey }) {
-        if (isDefined(partitionId) && isDefined(partitionKey)) {
-            throw new Error(`The partitionId (${partitionId}) and partitionKey (${partitionKey}) cannot both be specified.`);
-        }
-        if (!this._partitions.length) {
-            throw new Error(`Unable to determine partitionIds, can't assign partitionId.`);
-        }
-        if (isDefined(partitionId) && this._partitions.includes(partitionId)) {
-            return partitionId;
-        }
-        if (isDefined(partitionKey)) {
-            return mapPartitionKeyToId(partitionKey, this._partitions.length).toString();
-        }
-        return this._assignRoundRobinPartition();
-    }
-    _assignRoundRobinPartition() {
-        const maxPartitionIndex = this._partitions.length - 1;
-        const proposedPartitionIndex = this._lastRoundRobinPartitionIndex + 1;
-        const nextPartitionIndex = proposedPartitionIndex > maxPartitionIndex ? 0 : proposedPartitionIndex;
-        this._lastRoundRobinPartitionIndex = nextPartitionIndex;
-        return this._partitions[nextPartitionIndex];
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-/**
- * 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.
- */
-class EventHubBufferedProducerClient {
-    constructor(fullyQualifiedNamespaceOrConnectionString1, eventHubNameOrOptions2, credentialOrOptions3, options4) {
-        /**
-         * Controls the `abortSignal` passed to each `BatchingPartitionChannel`.
-         * Used to signal when a channel should stop waiting for events.
-         */
-        this._abortController = new abortController.AbortController();
-        /**
-         * Indicates whether the client has been explicitly closed.
-         */
-        this._isClosed = false;
-        /**
-         * Handles assigning partitions.
-         */
-        this._partitionAssigner = new PartitionAssigner();
-        /**
-         * The known partitionIds that will be used when assigning events to partitions.
-         */
-        this._partitionIds = [];
-        /**
-         * Mapping of partitionIds to `BatchingPartitionChannels`.
-         * Each `BatchingPartitionChannel` handles buffering events and backpressure independently.
-         */
-        this._partitionChannels = new Map();
-        if (typeof eventHubNameOrOptions2 !== "string") {
-            this._producer = new EventHubProducerClient(fullyQualifiedNamespaceOrConnectionString1, eventHubNameOrOptions2);
-            this._clientOptions = Object.assign({}, eventHubNameOrOptions2);
-        }
-        else if (!isCredential(credentialOrOptions3)) {
-            this._producer = new EventHubProducerClient(fullyQualifiedNamespaceOrConnectionString1, eventHubNameOrOptions2, credentialOrOptions3);
-            this._clientOptions = Object.assign({}, credentialOrOptions3);
-        }
-        else {
-            this._producer = new EventHubProducerClient(fullyQualifiedNamespaceOrConnectionString1, eventHubNameOrOptions2, credentialOrOptions3, options4);
-            this._clientOptions = Object.assign({}, options4);
-        }
-    }
-    /**
-     * @readonly
-     * The name of the Event Hub instance for which this client is created.
-     */
-    get eventHubName() {
-        return this._producer.eventHubName;
-    }
-    /**
-     * @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() {
-        return this._producer.fullyQualifiedNamespace;
-    }
-    /**
-     * 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.
-     */
-    async close(options = {}) {
-        if (!isDefined(options.flush) || options.flush === true) {
-            await this.flush(options);
-        }
-        // Calling abort signals to the BatchingPartitionChannels that they
-        // should stop reading/sending events.
-        this._abortController.abort();
-        return this._producer.close();
-    }
-    /**
-     * 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.
-     */
-    async enqueueEvent(event, options = {}) {
-        if (this._isClosed) {
-            throw new Error(`This EventHubBufferedProducerClient has already been closed. Create a new client to enqueue events.`);
-        }
-        // TODO: Start a loop that queries partition Ids.
-        // partition ids can be added to an Event Hub after it's been created.
-        if (!this._partitionIds.length) {
-            this._partitionIds = await this.getPartitionIds();
-            this._partitionAssigner.setPartitionIds(this._partitionIds);
-        }
-        const partitionId = this._partitionAssigner.assignPartition({
-            partitionId: options.partitionId,
-            partitionKey: options.partitionKey
-        });
-        const partitionChannel = this._getPartitionChannel(partitionId);
-        await partitionChannel.enqueueEvent(event);
-        return this._getTotalBufferedEventsCount();
-    }
-    /**
-     * 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.
-     */
-    async enqueueEvents(events, options = {}) {
-        for (const event of events) {
-            await this.enqueueEvent(event, options);
-        }
-        return this._getTotalBufferedEventsCount();
-    }
-    /**
-     * 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.
-     */
-    async flush(options = {}) {
-        await Promise.all(Array.from(this._partitionChannels.values()).map((channel) => channel.flush(options)));
-    }
-    /**
-     * 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 = {}) {
-        return this._producer.getEventHubProperties(options);
-    }
-    /**
-     * 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 = {}) {
-        return this._producer.getPartitionIds(options);
-    }
-    /**
-     * 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, options = {}) {
-        return this._producer.getPartitionProperties(partitionId, options);
-    }
-    /**
-     * Gets the `BatchingPartitionChannel` associated with the partitionId.
-     *
-     * If one does not exist, it is created.
-     */
-    _getPartitionChannel(partitionId) {
-        var _a;
-        const partitionChannel = (_a = this._partitionChannels.get(partitionId)) !== null && _a !== void 0 ? _a : new BatchingPartitionChannel({
-            loopAbortSignal: this._abortController.signal,
-            maxBufferSize: this._clientOptions.maxEventBufferLengthPerPartition || 1500,
-            maxWaitTimeInMs: this._clientOptions.maxWaitTimeInMs || 1000,
-            onSendEventsErrorHandler: this._clientOptions.onSendEventsErrorHandler,
-            onSendEventsSuccessHandler: this._clientOptions.onSendEventsSuccessHandler,
-            partitionId,
-            producer: this._producer
-        });
-        this._partitionChannels.set(partitionId, partitionChannel);
-        return partitionChannel;
-    }
-    /**
-     * Returns the total number of buffered events across all partitions.
-     */
-    _getTotalBufferedEventsCount() {
-        let total = 0;
-        for (const [_, channel] of this._partitionChannels) {
-            total += channel.getCurrentBufferedCount();
-        }
-        return total;
-    }
-}
-
 Object.defineProperty(exports, 'MessagingError', {
     enumerable: true,
     get: function () {
@@ -5155,7 +4465,6 @@ Object.defineProperty(exports, 'RetryMode', {
         return coreAmqp.RetryMode;
     }
 });
-exports.EventHubBufferedProducerClient = EventHubBufferedProducerClient;
 exports.EventHubConsumerClient = EventHubConsumerClient;
 exports.EventHubProducerClient = EventHubProducerClient;
 exports.earliestEventPosition = earliestEventPosition;