@azure/event-hubs 5.13.0-beta.2 → 6.0.0-alpha.20250128.2

package/dist/commonjs/index.js

@@ -0,0 +1,26 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEventHubConnectionString = exports.logger = exports.RetryMode = exports.MessagingError = exports.CloseReason = exports.earliestEventPosition = exports.latestEventPosition = exports.EventHubBufferedProducerClient = exports.EventHubProducerClient = exports.EventHubConsumerClient = void 0;
+const tslib_1 = require("tslib");
+var eventHubConsumerClient_js_1 = require("./eventHubConsumerClient.js");
+Object.defineProperty(exports, "EventHubConsumerClient", { enumerable: true, get: function () { return eventHubConsumerClient_js_1.EventHubConsumerClient; } });
+var eventHubProducerClient_js_1 = require("./eventHubProducerClient.js");
+Object.defineProperty(exports, "EventHubProducerClient", { enumerable: true, get: function () { return eventHubProducerClient_js_1.EventHubProducerClient; } });
+var eventHubBufferedProducerClient_js_1 = require("./eventHubBufferedProducerClient.js");
+Object.defineProperty(exports, "EventHubBufferedProducerClient", { enumerable: true, get: function () { return eventHubBufferedProducerClient_js_1.EventHubBufferedProducerClient; } });
+var eventPosition_js_1 = require("./eventPosition.js");
+Object.defineProperty(exports, "latestEventPosition", { enumerable: true, get: function () { return eventPosition_js_1.latestEventPosition; } });
+Object.defineProperty(exports, "earliestEventPosition", { enumerable: true, get: function () { return eventPosition_js_1.earliestEventPosition; } });
+var public_js_1 = require("./models/public.js");
+Object.defineProperty(exports, "CloseReason", { enumerable: true, get: function () { return public_js_1.CloseReason; } });
+var core_amqp_1 = require("@azure/core-amqp");
+Object.defineProperty(exports, "MessagingError", { enumerable: true, get: function () { return core_amqp_1.MessagingError; } });
+Object.defineProperty(exports, "RetryMode", { enumerable: true, get: function () { return core_amqp_1.RetryMode; } });
+var logger_js_1 = require("./logger.js");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_js_1.logger; } });
+var connectionStringUtils_js_1 = require("./util/connectionStringUtils.js");
+Object.defineProperty(exports, "parseEventHubConnectionString", { enumerable: true, get: function () { return connectionStringUtils_js_1.parseEventHubConnectionString; } });
+tslib_1.__exportStar(require("./eventDataAdapter.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;;AAgBlC,yEAAqE;AAA5D,mIAAA,sBAAsB,OAAA;AAC/B,yEAAqE;AAA5D,mIAAA,sBAAsB,OAAA;AAC/B,yFAQ6C;AAN3C,mJAAA,8BAA8B,OAAA;AAiBhC,uDAA+F;AAAvE,uHAAA,mBAAmB,OAAA;AAAE,yHAAA,qBAAqB,OAAA;AAKlE,gDAAiD;AAAxC,wGAAA,WAAW,OAAA;AACpB,8CAA6F;AAApF,2GAAA,cAAc,OAAA;AAAgB,sGAAA,SAAS,OAAA;AAEhD,yCAAqC;AAA5B,mGAAA,MAAM,OAAA;AACf,4EAGyC;AAFvC,yIAAA,6BAA6B,OAAA;AAI/B,gEAAsC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport { EventData, ReceivedEventData } from \"./eventData.js\";\nexport { WebSocketImpl } from \"rhea-promise\";\nexport { LastEnqueuedEventProperties } from \"./partitionReceiver.js\";\nexport { OperationOptions } from \"./util/operationOptions.js\";\nexport {\n  EventHubClientOptions,\n  EventHubConsumerClientOptions,\n  LoadBalancingOptions,\n  SendBatchOptions,\n  CreateBatchOptions,\n  GetPartitionIdsOptions,\n  GetPartitionPropertiesOptions,\n  GetEventHubPropertiesOptions,\n} from \"./models/public.js\";\nexport { EventHubConsumerClient } from \"./eventHubConsumerClient.js\";\nexport { EventHubProducerClient } from \"./eventHubProducerClient.js\";\nexport {\n  BufferedCloseOptions,\n  EventHubBufferedProducerClient,\n  EventHubBufferedProducerClientOptions,\n  EnqueueEventOptions,\n  BufferedFlushOptions,\n  OnSendEventsErrorContext,\n  OnSendEventsSuccessContext,\n} from \"./eventHubBufferedProducerClient.js\";\nexport {\n  SubscribeOptions,\n  Subscription,\n  SubscriptionEventHandlers,\n  PartitionContext,\n  ProcessErrorHandler,\n  ProcessInitializeHandler,\n  ProcessCloseHandler,\n  ProcessEventsHandler,\n} from \"./eventHubConsumerClientModels.js\";\nexport { EventPosition, latestEventPosition, earliestEventPosition } from \"./eventPosition.js\";\nexport { PartitionProperties, EventHubProperties } from \"./managementClient.js\";\nexport { EventDataBatch, TryAddOptions } from \"./eventDataBatch.js\";\nexport { Checkpoint } from \"./partitionProcessor.js\";\nexport { CheckpointStore, PartitionOwnership } from \"./eventProcessor.js\";\nexport { CloseReason } from \"./models/public.js\";\nexport { MessagingError, RetryOptions, RetryMode, WebSocketOptions } from \"@azure/core-amqp\";\nexport { TokenCredential } from \"@azure/core-auth\";\nexport { logger } from \"./logger.js\";\nexport {\n  parseEventHubConnectionString,\n  EventHubConnectionStringProperties,\n} from \"./util/connectionStringUtils.js\";\n\nexport * from \"./eventDataAdapter.js\";\n"]}

package/dist/commonjs/loadBalancerStrategies/balancedStrategy.d.ts

@@ -0,0 +1,30 @@
+import type { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * The BalancedLoadBalancerStrategy is meant to be used when the user
+ * wants to reach a load balanced state with less partition 'thrashing'.
+ *
+ * Partition thrashing - where a partition changes owners - is minimized
+ * by only returning a single partition to claim at a time.
+ * This minimizes the number of times a partition should need to be stolen.
+ * @internal
+ */
+export declare class BalancedLoadBalancingStrategy implements LoadBalancingStrategy {
+    private readonly _partitionOwnershipExpirationIntervalInMs;
+    /**
+     * Creates an instance of BalancedLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs: number);
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+//# sourceMappingURL=balancedStrategy.d.ts.map

package/dist/commonjs/loadBalancerStrategies/balancedStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balancedStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/balancedStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;;;GAQG;AACH,qBAAa,6BAA8B,YAAW,qBAAqB;IAM7D,OAAO,CAAC,QAAQ,CAAC,yCAAyC;IALtE;;;;OAIG;gBAC0B,yCAAyC,EAAE,MAAM;IAE9E;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAU,EAAE,MAAM,EAClB,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE;CAeZ"}

package/dist/commonjs/loadBalancerStrategies/balancedStrategy.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancedLoadBalancingStrategy = void 0;
+const loadBalancingStrategy_js_1 = require("./loadBalancingStrategy.js");
+/**
+ * The BalancedLoadBalancerStrategy is meant to be used when the user
+ * wants to reach a load balanced state with less partition 'thrashing'.
+ *
+ * Partition thrashing - where a partition changes owners - is minimized
+ * by only returning a single partition to claim at a time.
+ * This minimizes the number of times a partition should need to be stolen.
+ * @internal
+ */
+class BalancedLoadBalancingStrategy {
+    /**
+     * Creates an instance of BalancedLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs) {
+        this._partitionOwnershipExpirationIntervalInMs = _partitionOwnershipExpirationIntervalInMs;
+    }
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId, claimedPartitionOwnershipMap, partitionIds) {
+        const claimablePartitions = (0, loadBalancingStrategy_js_1.listAvailablePartitions)(ourOwnerId, claimedPartitionOwnershipMap, partitionIds, this._partitionOwnershipExpirationIntervalInMs);
+        if (!claimablePartitions.length) {
+            return [];
+        }
+        const randomIndex = Math.floor(Math.random() * claimablePartitions.length);
+        return [claimablePartitions[randomIndex]];
+    }
+}
+exports.BalancedLoadBalancingStrategy = BalancedLoadBalancingStrategy;
+//# sourceMappingURL=balancedStrategy.js.map

package/dist/commonjs/loadBalancerStrategies/balancedStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"balancedStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/balancedStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAGlC,yEAAqE;AAGrE;;;;;;;;GAQG;AACH,MAAa,6BAA6B;IACxC;;;;OAIG;IACH,YAA6B,yCAAiD;QAAjD,8CAAyC,GAAzC,yCAAyC,CAAQ;IAAG,CAAC;IAElF;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAkB,EAClB,4BAA6D,EAC7D,YAAsB;QAEtB,MAAM,mBAAmB,GAAG,IAAA,kDAAuB,EACjD,UAAU,EACV,4BAA4B,EAC5B,YAAY,EACZ,IAAI,CAAC,yCAAyC,CAC/C,CAAC;QAEF,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,CAAC;YAChC,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAC3E,OAAO,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC;IAC5C,CAAC;CACF;AAnCD,sEAmCC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { LoadBalancingStrategy } from \"./loadBalancingStrategy.js\";\nimport { listAvailablePartitions } from \"./loadBalancingStrategy.js\";\nimport type { PartitionOwnership } from \"../eventProcessor.js\";\n\n/**\n * The BalancedLoadBalancerStrategy is meant to be used when the user\n * wants to reach a load balanced state with less partition 'thrashing'.\n *\n * Partition thrashing - where a partition changes owners - is minimized\n * by only returning a single partition to claim at a time.\n * This minimizes the number of times a partition should need to be stolen.\n * @internal\n */\nexport class BalancedLoadBalancingStrategy implements LoadBalancingStrategy {\n  /**\n   * Creates an instance of BalancedLoadBalancingStrategy.\n   *\n   * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.\n   */\n  constructor(private readonly _partitionOwnershipExpirationIntervalInMs: number) {}\n\n  /**\n   * Implements load balancing by taking into account current ownership and\n   * the full set of partitions in the Event Hub.\n   * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.\n   * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n   * @param partitionIds - Partitions to assign owners to.\n   * @returns Partition ids to claim.\n   */\n  public getPartitionsToClaim(\n    ourOwnerId: string,\n    claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n    partitionIds: string[],\n  ): string[] {\n    const claimablePartitions = listAvailablePartitions(\n      ourOwnerId,\n      claimedPartitionOwnershipMap,\n      partitionIds,\n      this._partitionOwnershipExpirationIntervalInMs,\n    );\n\n    if (!claimablePartitions.length) {\n      return [];\n    }\n\n    const randomIndex = Math.floor(Math.random() * claimablePartitions.length);\n    return [claimablePartitions[randomIndex]];\n  }\n}\n"]}

package/dist/commonjs/loadBalancerStrategies/greedyStrategy.d.ts

@@ -0,0 +1,24 @@
+import type { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * @internal
+ */
+export declare class GreedyLoadBalancingStrategy implements LoadBalancingStrategy {
+    private readonly _partitionOwnershipExpirationIntervalInMs;
+    /**
+     * Creates an instance of GreedyLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs: number);
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the new set of partitions to add.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+//# sourceMappingURL=greedyStrategy.d.ts.map

package/dist/commonjs/loadBalancerStrategies/greedyStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greedyStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/greedyStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;GAEG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IAM3D,OAAO,CAAC,QAAQ,CAAC,yCAAyC;IALtE;;;;OAIG;gBAC0B,yCAAyC,EAAE,MAAM;IAE9E;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAU,EAAE,MAAM,EAClB,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE;CAQZ"}

package/dist/commonjs/loadBalancerStrategies/greedyStrategy.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GreedyLoadBalancingStrategy = void 0;
+const loadBalancingStrategy_js_1 = require("./loadBalancingStrategy.js");
+/**
+ * @internal
+ */
+class GreedyLoadBalancingStrategy {
+    /**
+     * Creates an instance of GreedyLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs) {
+        this._partitionOwnershipExpirationIntervalInMs = _partitionOwnershipExpirationIntervalInMs;
+    }
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the new set of partitions to add.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId, claimedPartitionOwnershipMap, partitionIds) {
+        return (0, loadBalancingStrategy_js_1.listAvailablePartitions)(ourOwnerId, claimedPartitionOwnershipMap, partitionIds, this._partitionOwnershipExpirationIntervalInMs);
+    }
+}
+exports.GreedyLoadBalancingStrategy = GreedyLoadBalancingStrategy;
+//# sourceMappingURL=greedyStrategy.js.map

package/dist/commonjs/loadBalancerStrategies/greedyStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greedyStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/greedyStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAGlC,yEAAqE;AAGrE;;GAEG;AACH,MAAa,2BAA2B;IACtC;;;;OAIG;IACH,YAA6B,yCAAiD;QAAjD,8CAAyC,GAAzC,yCAAyC,CAAQ;IAAG,CAAC;IAElF;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAkB,EAClB,4BAA6D,EAC7D,YAAsB;QAEtB,OAAO,IAAA,kDAAuB,EAC5B,UAAU,EACV,4BAA4B,EAC5B,YAAY,EACZ,IAAI,CAAC,yCAAyC,CAC/C,CAAC;IACJ,CAAC;CACF;AA5BD,kEA4BC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { LoadBalancingStrategy } from \"./loadBalancingStrategy.js\";\nimport { listAvailablePartitions } from \"./loadBalancingStrategy.js\";\nimport type { PartitionOwnership } from \"../eventProcessor.js\";\n\n/**\n * @internal\n */\nexport class GreedyLoadBalancingStrategy implements LoadBalancingStrategy {\n  /**\n   * Creates an instance of GreedyLoadBalancingStrategy.\n   *\n   * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.\n   */\n  constructor(private readonly _partitionOwnershipExpirationIntervalInMs: number) {}\n\n  /**\n   * Implements load balancing by taking into account current ownership and\n   * the new set of partitions to add.\n   * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.\n   * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n   * @param partitionIds - Partitions to assign owners to.\n   * @returns Partition ids to claim.\n   */\n  public getPartitionsToClaim(\n    ourOwnerId: string,\n    claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n    partitionIds: string[],\n  ): string[] {\n    return listAvailablePartitions(\n      ourOwnerId,\n      claimedPartitionOwnershipMap,\n      partitionIds,\n      this._partitionOwnershipExpirationIntervalInMs,\n    );\n  }\n}\n"]}

package/dist/commonjs/loadBalancerStrategies/loadBalancingStrategy.d.ts

@@ -0,0 +1,28 @@
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * Determines which partitions to claim as part of load balancing.
+ * @internal
+ */
+export interface LoadBalancingStrategy {
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ownerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+/**
+ * Identifies all of the partitions that can be claimed by the specified owner for
+ * that owner to reach a balanced state.
+ * @param OwnerId - The id we should assume is _our_ id when checking for ownership.
+ * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+ * @param partitionIds - Partitions to assign owners to.
+ * @param expirationIntervalInMs - The length of time a partition claim is valid.
+ * @returns Partition ids that may be claimed.
+ * @internal
+ */
+export declare function listAvailablePartitions(ownerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[], expirationIntervalInMs: number): string[];
+//# sourceMappingURL=loadBalancingStrategy.d.ts.map

package/dist/commonjs/loadBalancerStrategies/loadBalancingStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadBalancingStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/loadBalancingStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG/D;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;OAOG;IACH,oBAAoB,CAClB,OAAO,EAAE,MAAM,EACf,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE,CAAC;CACb;AA2PD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,EACtB,sBAAsB,EAAE,MAAM,GAC7B,MAAM,EAAE,CA8FV"}

package/dist/commonjs/loadBalancerStrategies/loadBalancingStrategy.js

@@ -0,0 +1,248 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAvailablePartitions = listAvailablePartitions;
+const logger_js_1 = require("../logger.js");
+/**
+ * This method will create a new map of partition id and PartitionOwnership containing only those partitions
+ * that are actively owned.
+ * All entries in the original map that haven't been modified for a duration of time greater than the allowed
+ * inactivity time limit are assumed to be owned by dead event processors.
+ * These will not be included in the map returned by this method.
+ *
+ * @param partitionOwnershipMap - The existing PartitionOwnerships mapped by partition.
+ * @param expirationIntervalInMs - The length of time a PartitionOwnership claim is valid.
+ */
+function getActivePartitionOwnerships(partitionOwnershipMap, expirationIntervalInMs) {
+    const activePartitionOwnershipMap = new Map();
+    partitionOwnershipMap.forEach((partitionOwnership, partitionId) => {
+        // If lastModifiedtimeInMs is missing, assume it is inactive.
+        if (typeof partitionOwnership.lastModifiedTimeInMs === "undefined" ||
+            partitionOwnership.lastModifiedTimeInMs === null) {
+            return;
+        }
+        const timeSincePartitionClaimed = Date.now() - partitionOwnership.lastModifiedTimeInMs;
+        if (timeSincePartitionClaimed < expirationIntervalInMs && partitionOwnership.ownerId) {
+            activePartitionOwnershipMap.set(partitionId, partitionOwnership);
+        }
+    });
+    return activePartitionOwnershipMap;
+}
+/**
+ * Calculates the minimum number of partitions each EventProcessor should own,
+ * and the number of EventProcessors that should have an extra partition assigned.
+ * @param ownerToOwnershipMap - The current ownerships for partitions.
+ * @param partitionIds - The full list of the Event Hub's partition ids.
+ * @internal
+ */
+function calculateBalancedLoadCounts(ownerToOwnershipMap, partitionIds) {
+    // Calculate the minimum number of partitions every EventProcessor should own when the load
+    // is evenly distributed.
+    const minPartitionsPerOwner = Math.floor(partitionIds.length / ownerToOwnershipMap.size);
+    // If the number of partitions in the Event Hub is not evenly divisible by the number of active
+    // EventProcesrrors, some EventProcessors may own 1 partition in addition to the minimum when the
+    // load is balanced.
+    // Calculate the number of EventProcessors that can own an additional partition.
+    const requiredNumberOfOwnersWithExtraPartition = partitionIds.length % ownerToOwnershipMap.size;
+    return {
+        minPartitionsPerOwner,
+        requiredNumberOfOwnersWithExtraPartition,
+    };
+}
+/**
+ * Counts the EventProcessors and tallies them by type.
+ *
+ * To be in balance we need to make sure that each EventProcessor is only consuming
+ * their fair share.
+ *
+ * When the partitions are divvied up we will sometimes end up with some EventProcessors
+ * that will have 1 more partition than others.
+ * This can happen if the number of partitions is not evenly divisible by the number of EventProcessors.
+ *
+ * So this function largely exists to support isLoadBalanced() and
+ * shouldOwnMorePartitions(), both of which depend on knowing if our current list
+ * of EventProcessors is actually in the proper state.
+ *
+ * @param minPartitionsPerOwner - The number of required partitions per EventProcessor.
+ * @param ownerToOwnershipMap - The current ownerships for partitions.
+ * @internal
+ */
+function getEventProcessorCounts(minPartitionsPerOwner, ownerToOwnershipMap) {
+    const counts = {
+        haveRequiredPartitions: 0,
+        haveAdditionalPartition: 0,
+        haveTooManyPartitions: 0,
+    };
+    for (const ownershipList of ownerToOwnershipMap.values()) {
+        const numberOfPartitions = ownershipList.length;
+        // there are basically three kinds of partition counts
+        // for a processor:
+        if (numberOfPartitions === minPartitionsPerOwner) {
+            // 1. Has _exactly_ the required number of partitions
+            counts.haveRequiredPartitions++;
+        }
+        else if (numberOfPartitions === minPartitionsPerOwner + 1) {
+            // 2. Has the required number plus one extra (correct in cases)
+            // where the # of partitions is not evenly divisible by the
+            // number of processors.
+            counts.haveAdditionalPartition++;
+        }
+        else if (numberOfPartitions > minPartitionsPerOwner + 1) {
+            // 3. has more than the possible # of partitions required
+            counts.haveTooManyPartitions++;
+        }
+    }
+    return counts;
+}
+/**
+ * Validates that we are currently in a balanced state - all EventProcessors own the
+ * minimum required number of partitions (and additional partitions, if the # of partitions
+ * is not evenly divisible by the # of EventProcessors).
+ *
+ * @param requiredNumberOfOwnersWithExtraPartition - The # of EventProcessors that process an additional partition, in addition to the required minimum.
+ * @param totalExpectedProcessors - The total # of EventProcessors we expect.
+ * @param eventProcessorCounts - EventProcessor counts, grouped by criteria.
+ * @internal
+ */
+function isLoadBalanced(requiredNumberOfOwnersWithExtraPartition, totalExpectedEventProcessors, { haveAdditionalPartition, haveRequiredPartitions }) {
+    return (haveAdditionalPartition === requiredNumberOfOwnersWithExtraPartition &&
+        haveRequiredPartitions + haveAdditionalPartition === totalExpectedEventProcessors);
+}
+/**
+ * Determines the number of new partitions to claim for this particular processor.
+ *
+ * @param minRequired - The minimum required number of partitions.
+ * @param requiredNumberOfOwnersWithExtraPartition - The current number of processors that should have an additional partition.
+ * @param numPartitionsOwnedByUs - The number of partitions we currently own.
+ * @param eventProcessorCounts - Processors, grouped by criteria.
+ * @internal
+ */
+function getNumberOfPartitionsToClaim(minRequiredPartitionCount, requiredNumberOfOwnersWithExtraPartition, numPartitionsOwnedByUs, { haveAdditionalPartition, haveTooManyPartitions }) {
+    let actualRequiredPartitionCount = minRequiredPartitionCount;
+    if (requiredNumberOfOwnersWithExtraPartition > 0 &&
+        // Eventually the `haveTooManyPartitions` will decay into `haveAdditionalPartition`
+        // EventProcessors as partitions are balanced to consumers that aren't at par.
+        // We can consider them to be `haveAdditionalPartition` EventProcessors for our purposes.
+        haveAdditionalPartition + haveTooManyPartitions < requiredNumberOfOwnersWithExtraPartition) {
+        // Overall we don't have enough EventProcessors that are taking on an additional partition
+        // so we should attempt to.
+        actualRequiredPartitionCount = minRequiredPartitionCount + 1;
+    }
+    return actualRequiredPartitionCount - numPartitionsOwnedByUs;
+}
+/**
+ * Determines which partitions can be stolen from other owners while maintaining
+ * a balanced state.
+ * @param numberOfPartitionsToClaim - The number of partitions the owner needs to claim to reach a balanced state.
+ * @param minPartitionsPerOwner - The minimum number of partitions each owner needs for the partition load to be balanced.
+ * @param requiredNumberOfOwnersWithExtraPartition - The number of owners that should have 1 extra partition.
+ * @param ourOwnerId - The id of _our_ owner.
+ * @param ownerToOwnershipMap - The current ownerships for partitions.
+ * @internal
+ */
+function findPartitionsToSteal(numberOfPartitionsToClaim, minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition, ourOwnerId, ownerToOwnershipMap) {
+    const partitionsToSteal = [];
+    // Create a list of PartitionOwnership lists that we can steal from.
+    const listOfPartitionOwnerships = [];
+    ownerToOwnershipMap.forEach((partitionOwnerships, ownerId) => {
+        if (ownerId === ourOwnerId || partitionOwnerships.length <= minPartitionsPerOwner)
+            return;
+        listOfPartitionOwnerships.push(partitionOwnerships);
+    });
+    // Sort the list in descending order based on the length of each element.
+    listOfPartitionOwnerships.sort((a, b) => {
+        if (a.length > b.length)
+            return -1;
+        if (a.length < b.length)
+            return 1;
+        return 0;
+    });
+    // Attempt to steal partitions from EventProcessors that have the most partitions 1st,
+    // then work our way down.
+    let ownersEncounteredWithExtraPartitions = 0;
+    let currentPartitionOwnershipList = listOfPartitionOwnerships.shift();
+    while (numberOfPartitionsToClaim > 0 && currentPartitionOwnershipList) {
+        let ownersExpectedPartitionCount = minPartitionsPerOwner;
+        // Determine if the current owner should be allowed to have an extra partition.
+        if (ownersEncounteredWithExtraPartitions < requiredNumberOfOwnersWithExtraPartition) {
+            ownersExpectedPartitionCount++;
+        }
+        ownersEncounteredWithExtraPartitions++;
+        let numberAvailableToSteal = currentPartitionOwnershipList.length - ownersExpectedPartitionCount;
+        // Claim as many random partitions as possible.
+        while (Math.min(numberOfPartitionsToClaim, numberAvailableToSteal)) {
+            const indexToClaim = Math.floor(Math.random() * currentPartitionOwnershipList.length);
+            partitionsToSteal.push(currentPartitionOwnershipList.splice(indexToClaim, 1)[0].partitionId);
+            numberOfPartitionsToClaim--;
+            numberAvailableToSteal--;
+        }
+        // Move on to the next list of PartitionOwnership.
+        currentPartitionOwnershipList = listOfPartitionOwnerships.shift();
+    }
+    return partitionsToSteal;
+}
+/**
+ * Identifies all of the partitions that can be claimed by the specified owner for
+ * that owner to reach a balanced state.
+ * @param OwnerId - The id we should assume is _our_ id when checking for ownership.
+ * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+ * @param partitionIds - Partitions to assign owners to.
+ * @param expirationIntervalInMs - The length of time a partition claim is valid.
+ * @returns Partition ids that may be claimed.
+ * @internal
+ */
+function listAvailablePartitions(ownerId, claimedPartitionOwnershipMap, partitionIds, expirationIntervalInMs) {
+    if (!partitionIds.length) {
+        return [];
+    }
+    // Collect only the PartitionOwnership that have been updated within the expiration interval.
+    // Any PartitionOwnership that has been updated outside the expiration interval can be claimed.
+    const activePartitionOwnershipMap = getActivePartitionOwnerships(claimedPartitionOwnershipMap, expirationIntervalInMs);
+    logger_js_1.logger.verbose(`[${ownerId}] Number of active ownership records: ${activePartitionOwnershipMap.size}.`);
+    if (activePartitionOwnershipMap.size === 0) {
+        // All partitions in this Event Hub are available to claim.
+        return partitionIds;
+    }
+    // Map ownerIds to the partitions they own so that we can determine how many each owner has.
+    const ownerToOwnershipMap = new Map();
+    for (const activeOwnership of activePartitionOwnershipMap.values()) {
+        const partitionOwnershipList = ownerToOwnershipMap.get(activeOwnership.ownerId) || [];
+        partitionOwnershipList.push(activeOwnership);
+        ownerToOwnershipMap.set(activeOwnership.ownerId, partitionOwnershipList);
+    }
+    // Add the current EventProcessor to the map of owners to ownerships if it doesn't exist.
+    if (!ownerToOwnershipMap.has(ownerId)) {
+        ownerToOwnershipMap.set(ownerId, []);
+    }
+    logger_js_1.logger.info(`[${ownerId}] Number of active event processors: ${ownerToOwnershipMap.size}.`);
+    const { minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition } = calculateBalancedLoadCounts(ownerToOwnershipMap, partitionIds);
+    logger_js_1.logger.verbose(`[${ownerId}] Expected minimum number of partitions per event processor: ${minPartitionsPerOwner},` +
+        `expected number of event processors with additional partition: ${requiredNumberOfOwnersWithExtraPartition}.`);
+    // Get some stats representing the current state the world with regards to how balanced the
+    // partitions are across EventProcessors.
+    const eventProcessorCounts = getEventProcessorCounts(minPartitionsPerOwner, ownerToOwnershipMap);
+    if (isLoadBalanced(requiredNumberOfOwnersWithExtraPartition, ownerToOwnershipMap.size, eventProcessorCounts)) {
+        // When the partitions are evenly distributed, no change required.
+        return [];
+    }
+    let numberOfPartitionsToClaim = getNumberOfPartitionsToClaim(minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition, ownerToOwnershipMap.get(ownerId).length, eventProcessorCounts);
+    if (numberOfPartitionsToClaim <= 0) {
+        return [];
+    }
+    const partitionsToClaim = [];
+    const unclaimedPartitionIds = partitionIds.filter((id) => !activePartitionOwnershipMap.has(id));
+    // Prioritize getting unclaimed partitions first.
+    while (Math.min(numberOfPartitionsToClaim, unclaimedPartitionIds.length)) {
+        const indexToClaim = Math.floor(Math.random() * unclaimedPartitionIds.length);
+        partitionsToClaim.push(unclaimedPartitionIds.splice(indexToClaim, 1)[0]);
+        numberOfPartitionsToClaim--;
+    }
+    if (numberOfPartitionsToClaim === 0) {
+        return partitionsToClaim;
+    }
+    // Find partitions that can be stolen from other EventProcessors.
+    const partitionsToSteal = findPartitionsToSteal(numberOfPartitionsToClaim, minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition, ownerId, ownerToOwnershipMap);
+    return partitionsToClaim.concat(partitionsToSteal);
+}
+//# sourceMappingURL=loadBalancingStrategy.js.map

package/dist/commonjs/loadBalancerStrategies/loadBalancingStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadBalancingStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/loadBalancingStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;AA4RlC,0DAmGC;AA5XD,4CAAsC;AA+CtC;;;;;;;;;GASG;AACH,SAAS,4BAA4B,CACnC,qBAAsD,EACtD,sBAA8B;IAE9B,MAAM,2BAA2B,GAAoC,IAAI,GAAG,EAAE,CAAC;IAC/E,qBAAqB,CAAC,OAAO,CAAC,CAAC,kBAAsC,EAAE,WAAmB,EAAE,EAAE;QAC5F,6DAA6D;QAC7D,IACE,OAAO,kBAAkB,CAAC,oBAAoB,KAAK,WAAW;YAC9D,kBAAkB,CAAC,oBAAoB,KAAK,IAAI,EAChD,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,yBAAyB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,kBAAkB,CAAC,oBAAoB,CAAC;QACvF,IAAI,yBAAyB,GAAG,sBAAsB,IAAI,kBAAkB,CAAC,OAAO,EAAE,CAAC;YACrF,2BAA2B,CAAC,GAAG,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC;QACnE,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,2BAA2B,CAAC;AACrC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,2BAA2B,CAClC,mBAAsD,EACtD,YAAsB;IAEtB,2FAA2F;IAC3F,yBAAyB;IACzB,MAAM,qBAAqB,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAEzF,+FAA+F;IAC/F,iGAAiG;IACjG,oBAAoB;IACpB,gFAAgF;IAChF,MAAM,wCAAwC,GAAG,YAAY,CAAC,MAAM,GAAG,mBAAmB,CAAC,IAAI,CAAC;IAEhG,OAAO;QACL,qBAAqB;QACrB,wCAAwC;KACzC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,uBAAuB,CAC9B,qBAA6B,EAC7B,mBAAsD;IAEtD,MAAM,MAAM,GAAyB;QACnC,sBAAsB,EAAE,CAAC;QACzB,uBAAuB,EAAE,CAAC;QAC1B,qBAAqB,EAAE,CAAC;KACzB,CAAC;IAEF,KAAK,MAAM,aAAa,IAAI,mBAAmB,CAAC,MAAM,EAAE,EAAE,CAAC;QACzD,MAAM,kBAAkB,GAAG,aAAa,CAAC,MAAM,CAAC;QAEhD,sDAAsD;QACtD,mBAAmB;QAEnB,IAAI,kBAAkB,KAAK,qBAAqB,EAAE,CAAC;YACjD,qDAAqD;YACrD,MAAM,CAAC,sBAAsB,EAAE,CAAC;QAClC,CAAC;aAAM,IAAI,kBAAkB,KAAK,qBAAqB,GAAG,CAAC,EAAE,CAAC;YAC5D,+DAA+D;YAC/D,2DAA2D;YAC3D,wBAAwB;YACxB,MAAM,CAAC,uBAAuB,EAAE,CAAC;QACnC,CAAC;aAAM,IAAI,kBAAkB,GAAG,qBAAqB,GAAG,CAAC,EAAE,CAAC;YAC1D,yDAAyD;YACzD,MAAM,CAAC,qBAAqB,EAAE,CAAC;QACjC,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,cAAc,CACrB,wCAAgD,EAChD,4BAAoC,EACpC,EAAE,uBAAuB,EAAE,sBAAsB,EAAwB;IAEzE,OAAO,CACL,uBAAuB,KAAK,wCAAwC;QACpE,sBAAsB,GAAG,uBAAuB,KAAK,4BAA4B,CAClF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,4BAA4B,CACnC,yBAAiC,EACjC,wCAAgD,EAChD,sBAA8B,EAC9B,EAAE,uBAAuB,EAAE,qBAAqB,EAAwB;IAExE,IAAI,4BAA4B,GAAG,yBAAyB,CAAC;IAE7D,IACE,wCAAwC,GAAG,CAAC;QAC5C,mFAAmF;QACnF,8EAA8E;QAC9E,yFAAyF;QACzF,uBAAuB,GAAG,qBAAqB,GAAG,wCAAwC,EAC1F,CAAC;QACD,0FAA0F;QAC1F,2BAA2B;QAC3B,4BAA4B,GAAG,yBAAyB,GAAG,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,4BAA4B,GAAG,sBAAsB,CAAC;AAC/D,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,qBAAqB,CAC5B,yBAAiC,EACjC,qBAA6B,EAC7B,wCAAgD,EAChD,UAAkB,EAClB,mBAAsD;IAEtD,MAAM,iBAAiB,GAAa,EAAE,CAAC;IACvC,oEAAoE;IACpE,MAAM,yBAAyB,GAAgC,EAAE,CAAC;IAClE,mBAAmB,CAAC,OAAO,CAAC,CAAC,mBAAmB,EAAE,OAAO,EAAE,EAAE;QAC3D,IAAI,OAAO,KAAK,UAAU,IAAI,mBAAmB,CAAC,MAAM,IAAI,qBAAqB;YAAE,OAAO;QAC1F,yBAAyB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,yEAAyE;IACzE,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACtC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM;YAAE,OAAO,CAAC,CAAC,CAAC;QACnC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM;YAAE,OAAO,CAAC,CAAC;QAClC,OAAO,CAAC,CAAC;IACX,CAAC,CAAC,CAAC;IAEH,sFAAsF;IACtF,0BAA0B;IAC1B,IAAI,oCAAoC,GAAG,CAAC,CAAC;IAC7C,IAAI,6BAA6B,GAAG,yBAAyB,CAAC,KAAK,EAAE,CAAC;IACtE,OAAO,yBAAyB,GAAG,CAAC,IAAI,6BAA6B,EAAE,CAAC;QACtE,IAAI,4BAA4B,GAAG,qBAAqB,CAAC;QACzD,+EAA+E;QAC/E,IAAI,oCAAoC,GAAG,wCAAwC,EAAE,CAAC;YACpF,4BAA4B,EAAE,CAAC;QACjC,CAAC;QACD,oCAAoC,EAAE,CAAC;QAEvC,IAAI,sBAAsB,GACxB,6BAA6B,CAAC,MAAM,GAAG,4BAA4B,CAAC;QACtE,+CAA+C;QAC/C,OAAO,IAAI,CAAC,GAAG,CAAC,yBAAyB,EAAE,sBAAsB,CAAC,EAAE,CAAC;YACnE,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,6BAA6B,CAAC,MAAM,CAAC,CAAC;YACtF,iBAAiB,CAAC,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;YAC7F,yBAAyB,EAAE,CAAC;YAC5B,sBAAsB,EAAE,CAAC;QAC3B,CAAC;QAED,kDAAkD;QAClD,6BAA6B,GAAG,yBAAyB,CAAC,KAAK,EAAE,CAAC;IACpE,CAAC;IAED,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,uBAAuB,CACrC,OAAe,EACf,4BAA6D,EAC7D,YAAsB,EACtB,sBAA8B;IAE9B,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,6FAA6F;IAC7F,+FAA+F;IAC/F,MAAM,2BAA2B,GAAG,4BAA4B,CAC9D,4BAA4B,EAC5B,sBAAsB,CACvB,CAAC;IACF,kBAAM,CAAC,OAAO,CACZ,IAAI,OAAO,yCAAyC,2BAA2B,CAAC,IAAI,GAAG,CACxF,CAAC;IAEF,IAAI,2BAA2B,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QAC3C,2DAA2D;QAC3D,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,4FAA4F;IAC5F,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAgC,CAAC;IACpE,KAAK,MAAM,eAAe,IAAI,2BAA2B,CAAC,MAAM,EAAE,EAAE,CAAC;QACnE,MAAM,sBAAsB,GAAG,mBAAmB,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAEtF,sBAAsB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC7C,mBAAmB,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC;IAC3E,CAAC;IAED,yFAAyF;IACzF,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,mBAAmB,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACvC,CAAC;IAED,kBAAM,CAAC,IAAI,CAAC,IAAI,OAAO,wCAAwC,mBAAmB,CAAC,IAAI,GAAG,CAAC,CAAC;IAE5F,MAAM,EAAE,qBAAqB,EAAE,wCAAwC,EAAE,GACvE,2BAA2B,CAAC,mBAAmB,EAAE,YAAY,CAAC,CAAC;IAEjE,kBAAM,CAAC,OAAO,CACZ,IAAI,OAAO,gEAAgE,qBAAqB,GAAG;QACjG,kEAAkE,wCAAwC,GAAG,CAChH,CAAC;IAEF,2FAA2F;IAC3F,yCAAyC;IACzC,MAAM,oBAAoB,GAAG,uBAAuB,CAAC,qBAAqB,EAAE,mBAAmB,CAAC,CAAC;IAEjG,IACE,cAAc,CACZ,wCAAwC,EACxC,mBAAmB,CAAC,IAAI,EACxB,oBAAoB,CACrB,EACD,CAAC;QACD,kEAAkE;QAClE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,yBAAyB,GAAG,4BAA4B,CAC1D,qBAAqB,EACrB,wCAAwC,EACxC,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAE,CAAC,MAAM,EACxC,oBAAoB,CACrB,CAAC;IAEF,IAAI,yBAAyB,IAAI,CAAC,EAAE,CAAC;QACnC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,iBAAiB,GAAa,EAAE,CAAC;IACvC,MAAM,qBAAqB,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,2BAA2B,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAEhG,iDAAiD;IACjD,OAAO,IAAI,CAAC,GAAG,CAAC,yBAAyB,EAAE,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;QACzE,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAC9E,iBAAiB,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACzE,yBAAyB,EAAE,CAAC;IAC9B,CAAC;IAED,IAAI,yBAAyB,KAAK,CAAC,EAAE,CAAC;QACpC,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED,iEAAiE;IACjE,MAAM,iBAAiB,GAAG,qBAAqB,CAC7C,yBAAyB,EACzB,qBAAqB,EACrB,wCAAwC,EACxC,OAAO,EACP,mBAAmB,CACpB,CAAC;IAEF,OAAO,iBAAiB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;AACrD,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PartitionOwnership } from \"../eventProcessor.js\";\nimport { logger } from \"../logger.js\";\n\n/**\n * Determines which partitions to claim as part of load balancing.\n * @internal\n */\nexport interface LoadBalancingStrategy {\n  /**\n   * Implements load balancing by taking into account current ownership and\n   * the full set of partitions in the Event Hub.\n   * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.\n   * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n   * @param partitionIds - Partitions to assign owners to.\n   * @returns Partition ids to claim.\n   */\n  getPartitionsToClaim(\n    ownerId: string,\n    claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n    partitionIds: string[],\n  ): string[];\n}\n\n/**\n * Counts of the EventProcessors that currently own partitions.\n * @internal\n */\ninterface EventProcessorCounts {\n  /**\n   * The # of EventProcessors that only own the required # of\n   * partitions.\n   */\n  haveRequiredPartitions: number;\n  /**\n   * The # of EventProcessors that currently own the required #\n   * of partitions + 1 additional (ie, handling the case where\n   * the number of partitions is not evenly divisible by the # of\n   * EventProcessors).\n   */\n  haveAdditionalPartition: number;\n  /**\n   * EventProcessors which have more than the required or even required + 1\n   * number of partitions. These will eventually be downsized by other\n   * EventProcessors as they acquire their required number of partitions.\n   */\n  haveTooManyPartitions: number;\n}\n\n/**\n * This method will create a new map of partition id and PartitionOwnership containing only those partitions\n * that are actively owned.\n * All entries in the original map that haven't been modified for a duration of time greater than the allowed\n * inactivity time limit are assumed to be owned by dead event processors.\n * These will not be included in the map returned by this method.\n *\n * @param partitionOwnershipMap - The existing PartitionOwnerships mapped by partition.\n * @param expirationIntervalInMs - The length of time a PartitionOwnership claim is valid.\n */\nfunction getActivePartitionOwnerships(\n  partitionOwnershipMap: Map<string, PartitionOwnership>,\n  expirationIntervalInMs: number,\n): Map<string, PartitionOwnership> {\n  const activePartitionOwnershipMap: Map<string, PartitionOwnership> = new Map();\n  partitionOwnershipMap.forEach((partitionOwnership: PartitionOwnership, partitionId: string) => {\n    // If lastModifiedtimeInMs is missing, assume it is inactive.\n    if (\n      typeof partitionOwnership.lastModifiedTimeInMs === \"undefined\" ||\n      partitionOwnership.lastModifiedTimeInMs === null\n    ) {\n      return;\n    }\n\n    const timeSincePartitionClaimed = Date.now() - partitionOwnership.lastModifiedTimeInMs;\n    if (timeSincePartitionClaimed < expirationIntervalInMs && partitionOwnership.ownerId) {\n      activePartitionOwnershipMap.set(partitionId, partitionOwnership);\n    }\n  });\n\n  return activePartitionOwnershipMap;\n}\n\n/**\n * Calculates the minimum number of partitions each EventProcessor should own,\n * and the number of EventProcessors that should have an extra partition assigned.\n * @param ownerToOwnershipMap - The current ownerships for partitions.\n * @param partitionIds - The full list of the Event Hub's partition ids.\n * @internal\n */\nfunction calculateBalancedLoadCounts(\n  ownerToOwnershipMap: Map<string, PartitionOwnership[]>,\n  partitionIds: string[],\n): { minPartitionsPerOwner: number; requiredNumberOfOwnersWithExtraPartition: number } {\n  // Calculate the minimum number of partitions every EventProcessor should own when the load\n  // is evenly distributed.\n  const minPartitionsPerOwner = Math.floor(partitionIds.length / ownerToOwnershipMap.size);\n\n  // If the number of partitions in the Event Hub is not evenly divisible by the number of active\n  // EventProcesrrors, some EventProcessors may own 1 partition in addition to the minimum when the\n  // load is balanced.\n  // Calculate the number of EventProcessors that can own an additional partition.\n  const requiredNumberOfOwnersWithExtraPartition = partitionIds.length % ownerToOwnershipMap.size;\n\n  return {\n    minPartitionsPerOwner,\n    requiredNumberOfOwnersWithExtraPartition,\n  };\n}\n\n/**\n * Counts the EventProcessors and tallies them by type.\n *\n * To be in balance we need to make sure that each EventProcessor is only consuming\n * their fair share.\n *\n * When the partitions are divvied up we will sometimes end up with some EventProcessors\n * that will have 1 more partition than others.\n * This can happen if the number of partitions is not evenly divisible by the number of EventProcessors.\n *\n * So this function largely exists to support isLoadBalanced() and\n * shouldOwnMorePartitions(), both of which depend on knowing if our current list\n * of EventProcessors is actually in the proper state.\n *\n * @param minPartitionsPerOwner - The number of required partitions per EventProcessor.\n * @param ownerToOwnershipMap - The current ownerships for partitions.\n * @internal\n */\nfunction getEventProcessorCounts(\n  minPartitionsPerOwner: number,\n  ownerToOwnershipMap: Map<string, PartitionOwnership[]>,\n): EventProcessorCounts {\n  const counts: EventProcessorCounts = {\n    haveRequiredPartitions: 0,\n    haveAdditionalPartition: 0,\n    haveTooManyPartitions: 0,\n  };\n\n  for (const ownershipList of ownerToOwnershipMap.values()) {\n    const numberOfPartitions = ownershipList.length;\n\n    // there are basically three kinds of partition counts\n    // for a processor:\n\n    if (numberOfPartitions === minPartitionsPerOwner) {\n      // 1. Has _exactly_ the required number of partitions\n      counts.haveRequiredPartitions++;\n    } else if (numberOfPartitions === minPartitionsPerOwner + 1) {\n      // 2. Has the required number plus one extra (correct in cases)\n      // where the # of partitions is not evenly divisible by the\n      // number of processors.\n      counts.haveAdditionalPartition++;\n    } else if (numberOfPartitions > minPartitionsPerOwner + 1) {\n      // 3. has more than the possible # of partitions required\n      counts.haveTooManyPartitions++;\n    }\n  }\n\n  return counts;\n}\n\n/**\n * Validates that we are currently in a balanced state - all EventProcessors own the\n * minimum required number of partitions (and additional partitions, if the # of partitions\n * is not evenly divisible by the # of EventProcessors).\n *\n * @param requiredNumberOfOwnersWithExtraPartition - The # of EventProcessors that process an additional partition, in addition to the required minimum.\n * @param totalExpectedProcessors - The total # of EventProcessors we expect.\n * @param eventProcessorCounts - EventProcessor counts, grouped by criteria.\n * @internal\n */\nfunction isLoadBalanced(\n  requiredNumberOfOwnersWithExtraPartition: number,\n  totalExpectedEventProcessors: number,\n  { haveAdditionalPartition, haveRequiredPartitions }: EventProcessorCounts,\n): boolean {\n  return (\n    haveAdditionalPartition === requiredNumberOfOwnersWithExtraPartition &&\n    haveRequiredPartitions + haveAdditionalPartition === totalExpectedEventProcessors\n  );\n}\n\n/**\n * Determines the number of new partitions to claim for this particular processor.\n *\n * @param minRequired - The minimum required number of partitions.\n * @param requiredNumberOfOwnersWithExtraPartition - The current number of processors that should have an additional partition.\n * @param numPartitionsOwnedByUs - The number of partitions we currently own.\n * @param eventProcessorCounts - Processors, grouped by criteria.\n * @internal\n */\nfunction getNumberOfPartitionsToClaim(\n  minRequiredPartitionCount: number,\n  requiredNumberOfOwnersWithExtraPartition: number,\n  numPartitionsOwnedByUs: number,\n  { haveAdditionalPartition, haveTooManyPartitions }: EventProcessorCounts,\n): number {\n  let actualRequiredPartitionCount = minRequiredPartitionCount;\n\n  if (\n    requiredNumberOfOwnersWithExtraPartition > 0 &&\n    // Eventually the `haveTooManyPartitions` will decay into `haveAdditionalPartition`\n    // EventProcessors as partitions are balanced to consumers that aren't at par.\n    // We can consider them to be `haveAdditionalPartition` EventProcessors for our purposes.\n    haveAdditionalPartition + haveTooManyPartitions < requiredNumberOfOwnersWithExtraPartition\n  ) {\n    // Overall we don't have enough EventProcessors that are taking on an additional partition\n    // so we should attempt to.\n    actualRequiredPartitionCount = minRequiredPartitionCount + 1;\n  }\n  return actualRequiredPartitionCount - numPartitionsOwnedByUs;\n}\n\n/**\n * Determines which partitions can be stolen from other owners while maintaining\n * a balanced state.\n * @param numberOfPartitionsToClaim - The number of partitions the owner needs to claim to reach a balanced state.\n * @param minPartitionsPerOwner - The minimum number of partitions each owner needs for the partition load to be balanced.\n * @param requiredNumberOfOwnersWithExtraPartition - The number of owners that should have 1 extra partition.\n * @param ourOwnerId - The id of _our_ owner.\n * @param ownerToOwnershipMap - The current ownerships for partitions.\n * @internal\n */\nfunction findPartitionsToSteal(\n  numberOfPartitionsToClaim: number,\n  minPartitionsPerOwner: number,\n  requiredNumberOfOwnersWithExtraPartition: number,\n  ourOwnerId: string,\n  ownerToOwnershipMap: Map<string, PartitionOwnership[]>,\n): string[] {\n  const partitionsToSteal: string[] = [];\n  // Create a list of PartitionOwnership lists that we can steal from.\n  const listOfPartitionOwnerships: Array<PartitionOwnership[]> = [];\n  ownerToOwnershipMap.forEach((partitionOwnerships, ownerId) => {\n    if (ownerId === ourOwnerId || partitionOwnerships.length <= minPartitionsPerOwner) return;\n    listOfPartitionOwnerships.push(partitionOwnerships);\n  });\n\n  // Sort the list in descending order based on the length of each element.\n  listOfPartitionOwnerships.sort((a, b) => {\n    if (a.length > b.length) return -1;\n    if (a.length < b.length) return 1;\n    return 0;\n  });\n\n  // Attempt to steal partitions from EventProcessors that have the most partitions 1st,\n  // then work our way down.\n  let ownersEncounteredWithExtraPartitions = 0;\n  let currentPartitionOwnershipList = listOfPartitionOwnerships.shift();\n  while (numberOfPartitionsToClaim > 0 && currentPartitionOwnershipList) {\n    let ownersExpectedPartitionCount = minPartitionsPerOwner;\n    // Determine if the current owner should be allowed to have an extra partition.\n    if (ownersEncounteredWithExtraPartitions < requiredNumberOfOwnersWithExtraPartition) {\n      ownersExpectedPartitionCount++;\n    }\n    ownersEncounteredWithExtraPartitions++;\n\n    let numberAvailableToSteal =\n      currentPartitionOwnershipList.length - ownersExpectedPartitionCount;\n    // Claim as many random partitions as possible.\n    while (Math.min(numberOfPartitionsToClaim, numberAvailableToSteal)) {\n      const indexToClaim = Math.floor(Math.random() * currentPartitionOwnershipList.length);\n      partitionsToSteal.push(currentPartitionOwnershipList.splice(indexToClaim, 1)[0].partitionId);\n      numberOfPartitionsToClaim--;\n      numberAvailableToSteal--;\n    }\n\n    // Move on to the next list of PartitionOwnership.\n    currentPartitionOwnershipList = listOfPartitionOwnerships.shift();\n  }\n\n  return partitionsToSteal;\n}\n\n/**\n * Identifies all of the partitions that can be claimed by the specified owner for\n * that owner to reach a balanced state.\n * @param OwnerId - The id we should assume is _our_ id when checking for ownership.\n * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n * @param partitionIds - Partitions to assign owners to.\n * @param expirationIntervalInMs - The length of time a partition claim is valid.\n * @returns Partition ids that may be claimed.\n * @internal\n */\nexport function listAvailablePartitions(\n  ownerId: string,\n  claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n  partitionIds: string[],\n  expirationIntervalInMs: number,\n): string[] {\n  if (!partitionIds.length) {\n    return [];\n  }\n\n  // Collect only the PartitionOwnership that have been updated within the expiration interval.\n  // Any PartitionOwnership that has been updated outside the expiration interval can be claimed.\n  const activePartitionOwnershipMap = getActivePartitionOwnerships(\n    claimedPartitionOwnershipMap,\n    expirationIntervalInMs,\n  );\n  logger.verbose(\n    `[${ownerId}] Number of active ownership records: ${activePartitionOwnershipMap.size}.`,\n  );\n\n  if (activePartitionOwnershipMap.size === 0) {\n    // All partitions in this Event Hub are available to claim.\n    return partitionIds;\n  }\n\n  // Map ownerIds to the partitions they own so that we can determine how many each owner has.\n  const ownerToOwnershipMap = new Map<string, PartitionOwnership[]>();\n  for (const activeOwnership of activePartitionOwnershipMap.values()) {\n    const partitionOwnershipList = ownerToOwnershipMap.get(activeOwnership.ownerId) || [];\n\n    partitionOwnershipList.push(activeOwnership);\n    ownerToOwnershipMap.set(activeOwnership.ownerId, partitionOwnershipList);\n  }\n\n  // Add the current EventProcessor to the map of owners to ownerships if it doesn't exist.\n  if (!ownerToOwnershipMap.has(ownerId)) {\n    ownerToOwnershipMap.set(ownerId, []);\n  }\n\n  logger.info(`[${ownerId}] Number of active event processors: ${ownerToOwnershipMap.size}.`);\n\n  const { minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition } =\n    calculateBalancedLoadCounts(ownerToOwnershipMap, partitionIds);\n\n  logger.verbose(\n    `[${ownerId}] Expected minimum number of partitions per event processor: ${minPartitionsPerOwner},` +\n      `expected number of event processors with additional partition: ${requiredNumberOfOwnersWithExtraPartition}.`,\n  );\n\n  // Get some stats representing the current state the world with regards to how balanced the\n  // partitions are across EventProcessors.\n  const eventProcessorCounts = getEventProcessorCounts(minPartitionsPerOwner, ownerToOwnershipMap);\n\n  if (\n    isLoadBalanced(\n      requiredNumberOfOwnersWithExtraPartition,\n      ownerToOwnershipMap.size,\n      eventProcessorCounts,\n    )\n  ) {\n    // When the partitions are evenly distributed, no change required.\n    return [];\n  }\n\n  let numberOfPartitionsToClaim = getNumberOfPartitionsToClaim(\n    minPartitionsPerOwner,\n    requiredNumberOfOwnersWithExtraPartition,\n    ownerToOwnershipMap.get(ownerId)!.length,\n    eventProcessorCounts,\n  );\n\n  if (numberOfPartitionsToClaim <= 0) {\n    return [];\n  }\n\n  const partitionsToClaim: string[] = [];\n  const unclaimedPartitionIds = partitionIds.filter((id) => !activePartitionOwnershipMap.has(id));\n\n  // Prioritize getting unclaimed partitions first.\n  while (Math.min(numberOfPartitionsToClaim, unclaimedPartitionIds.length)) {\n    const indexToClaim = Math.floor(Math.random() * unclaimedPartitionIds.length);\n    partitionsToClaim.push(unclaimedPartitionIds.splice(indexToClaim, 1)[0]);\n    numberOfPartitionsToClaim--;\n  }\n\n  if (numberOfPartitionsToClaim === 0) {\n    return partitionsToClaim;\n  }\n\n  // Find partitions that can be stolen from other EventProcessors.\n  const partitionsToSteal = findPartitionsToSteal(\n    numberOfPartitionsToClaim,\n    minPartitionsPerOwner,\n    requiredNumberOfOwnersWithExtraPartition,\n    ownerId,\n    ownerToOwnershipMap,\n  );\n\n  return partitionsToClaim.concat(partitionsToSteal);\n}\n"]}

package/dist/commonjs/loadBalancerStrategies/unbalancedStrategy.d.ts

@@ -0,0 +1,20 @@
+import type { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * The UnbalancedLoadBalancingStrategy does no actual load balancing.
+ * It is intended to be used when you want to avoid load balancing
+ * and consume a set of partitions.
+ * @internal
+ */
+export declare class UnbalancedLoadBalancingStrategy implements LoadBalancingStrategy {
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param _ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param _claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(_ourOwnerId: string, _claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+//# sourceMappingURL=unbalancedStrategy.d.ts.map

package/dist/commonjs/loadBalancerStrategies/unbalancedStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalancedStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/unbalancedStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;GAKG;AACH,qBAAa,+BAAgC,YAAW,qBAAqB;IAC3E;;;;;;;OAOG;IACI,oBAAoB,CACzB,WAAW,EAAE,MAAM,EACnB,6BAA6B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC9D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE;CAGZ"}

package/dist/commonjs/loadBalancerStrategies/unbalancedStrategy.js

@@ -0,0 +1,26 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnbalancedLoadBalancingStrategy = void 0;
+/**
+ * The UnbalancedLoadBalancingStrategy does no actual load balancing.
+ * It is intended to be used when you want to avoid load balancing
+ * and consume a set of partitions.
+ * @internal
+ */
+class UnbalancedLoadBalancingStrategy {
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param _ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param _claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(_ourOwnerId, _claimedPartitionOwnershipMap, partitionIds) {
+        return partitionIds;
+    }
+}
+exports.UnbalancedLoadBalancingStrategy = UnbalancedLoadBalancingStrategy;
+//# sourceMappingURL=unbalancedStrategy.js.map

package/dist/commonjs/loadBalancerStrategies/unbalancedStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalancedStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/unbalancedStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAKlC;;;;;GAKG;AACH,MAAa,+BAA+B;IAC1C;;;;;;;OAOG;IACI,oBAAoB,CACzB,WAAmB,EACnB,6BAA8D,EAC9D,YAAsB;QAEtB,OAAO,YAAY,CAAC;IACtB,CAAC;CACF;AAhBD,0EAgBC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { LoadBalancingStrategy } from \"./loadBalancingStrategy.js\";\nimport type { PartitionOwnership } from \"../eventProcessor.js\";\n\n/**\n * The UnbalancedLoadBalancingStrategy does no actual load balancing.\n * It is intended to be used when you want to avoid load balancing\n * and consume a set of partitions.\n * @internal\n */\nexport class UnbalancedLoadBalancingStrategy implements LoadBalancingStrategy {\n  /**\n   * Implements load balancing by taking into account current ownership and\n   * the full set of partitions in the Event Hub.\n   * @param _ourOwnerId - The id we should assume is _our_ id when checking for ownership.\n   * @param _claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n   * @param partitionIds - Partitions to assign owners to.\n   * @returns Partition ids to claim.\n   */\n  public getPartitionsToClaim(\n    _ourOwnerId: string,\n    _claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n    partitionIds: string[],\n  ): string[] {\n    return partitionIds;\n  }\n}\n"]}

package/dist/commonjs/logger.d.ts

@@ -0,0 +1,37 @@
+import type { AzureLogger, Debugger } from "@azure/logger";
+/**
+ * The `@azure/logger` configuration for this package.
+ * This will output logs using the `azure:event-hubs` namespace prefix.
+ */
+export declare const logger: AzureLogger;
+/**
+ * Logs the error's stack trace to "verbose" if a stack trace is available.
+ * @param error - Error containing a stack trace.
+ * @internal
+ */
+export declare function logErrorStackTrace(error: unknown): void;
+/**
+ * @internal
+ */
+export declare function createReceiverLogPrefix(consumerId: string, connectionId: string, partitionId: string): string;
+/**
+ * @internal
+ */
+export declare function createSenderLogPrefix(senderId: string, connectionId: string): string;
+/**
+ * @internal
+ */
+export declare function createManagementLogPrefix(connectionId: string): string;
+/**
+ * @internal
+ */
+export type SimpleLogger = {
+    [Property in keyof AzureLogger]: Debugger["log"];
+};
+/**
+ * @internal
+ */
+export declare function createSimpleLogger(azureLogger: AzureLogger, prefix: string): SimpleLogger;
+/** @internal */
+export declare function logObj(obj: unknown): void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/commonjs/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAiB,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI1E;;;GAGG;AACH,eAAO,MAAM,MAAM,aAAmC,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAIvD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEpF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;KACxB,QAAQ,IAAI,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC;CACjD,CAAC;AAcF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAOzF;AAED,gBAAgB;AAChB,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAEzC"}