@fluidframework/container-runtime 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/src/summarizerClientElection.ts

@@ -1,161 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IEvent, IEventProvider, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { TypedEventEmitter } from "@fluidframework/common-utils";
-import { IClientDetails, MessageType } from "@fluidframework/protocol-definitions";
-import { IOrderedClientElection, ISerializedElection, ITrackedClient } from "./orderedClientElection";
-import { ISummaryCollectionOpEvents } from "./summaryCollection";
-
-export const summarizerClientType = "summarizer";
-
-export interface ISummarizerClientElectionEvents extends IEvent {
-    (event: "electedSummarizerChanged", handler: () => void): void;
-}
-
-export interface ISummarizerClientElection extends IEventProvider<ISummarizerClientElectionEvents> {
-    readonly electedClientId: string | undefined;
-    readonly electedParentId: string | undefined;
-}
-
-/**
- * This class encapsulates logic around tracking the elected summarizer client.
- * It will handle updating the elected client when a summary ack hasn't been seen
- * for some configured number of ops.
- */
-export class SummarizerClientElection
-    extends TypedEventEmitter<ISummarizerClientElectionEvents>
-    implements ISummarizerClientElection {
-    /**
-     * Used to calculate number of ops since last summary ack for the current elected client.
-     * This will be undefined if there is no elected summarizer, or no summary ack has been
-     * observed since this client was elected.
-     * When a summary ack comes in, this will be set to the sequence number of the summary ack.
-     */
-    private lastSummaryAckSeqForClient: number | undefined;
-    /**
-     * Used to prevent excess logging by recording the sequence number that we last reported at,
-     * and making sure we don't report another event to telemetry. If things work as intended,
-     * this is not needed, otherwise it could report an event on every op in worst case scenario.
-     */
-    private lastReportedSeq = 0;
-
-    public get electedClientId() {
-        return this.clientElection.electedClient?.clientId;
-    }
-    public get electedParentId() {
-        return this.clientElection.electedParent?.clientId;
-    }
-
-    constructor(
-        private readonly logger: ITelemetryLogger,
-        private readonly summaryCollection: IEventProvider<ISummaryCollectionOpEvents>,
-        public readonly clientElection: IOrderedClientElection,
-        private readonly maxOpsSinceLastSummary: number,
-        private readonly electionEnabled: boolean,
-    ) {
-        super();
-        // On every inbound op, if enough ops pass without seeing a summary ack (per elected client),
-        // elect a new client and log to telemetry.
-        this.summaryCollection.on("default", ({ sequenceNumber }) => {
-            const electedClientId = this.electedClientId;
-            if (electedClientId === undefined) {
-                // Reset election if no elected client, but eligible clients are connected.
-                // This should be uncommon, but is possible if the initial state of the
-                // ordered client election contains an undefined client id or one not found
-                // in the quorum (the latter would already log an error).
-                if (this.clientElection.eligibleCount > 0) {
-                    this.clientElection.resetElectedClient(sequenceNumber);
-                }
-                return;
-            }
-            let electionSequenceNumber = this.clientElection.electionSequenceNumber;
-            const opsWithoutSummary = sequenceNumber - (this.lastSummaryAckSeqForClient ?? electionSequenceNumber);
-            if (opsWithoutSummary > this.maxOpsSinceLastSummary) {
-                // Log and elect a new summarizer client.
-                const opsSinceLastReport = sequenceNumber - this.lastReportedSeq;
-                if (opsSinceLastReport > this.maxOpsSinceLastSummary) {
-                    this.logger.sendTelemetryEvent({
-                        eventName: "ElectedClientNotSummarizing",
-                        electedClientId,
-                        lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
-                        electionSequenceNumber,
-                        nextElectedClientId: this.clientElection.peekNextElectedClient()?.clientId,
-                        electionEnabled: this.electionEnabled,
-                    });
-                    this.lastReportedSeq = sequenceNumber;
-                }
-
-                if (this.electionEnabled) {
-                    const previousParentId = this.electedParentId;
-                    this.clientElection.incrementElectedClient(sequenceNumber);
-
-                    // Verify that state incremented as expected. This should be reliable,
-                    // since all of OrderedClientElection is synchronous.
-                    electionSequenceNumber = this.clientElection.electionSequenceNumber;
-                    if (sequenceNumber > (this.lastSummaryAckSeqForClient ?? electionSequenceNumber)) {
-                        if (opsSinceLastReport > this.maxOpsSinceLastSummary) {
-                            this.logger.sendErrorEvent({
-                                eventName: "UnexpectedElectionSequenceNumber",
-                                // Expected to be undefined
-                                lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
-                                // Expected to be same as op sequenceNumber
-                                electionSequenceNumber,
-                                sequenceNumber,
-                                previousClientId: electedClientId,
-                                previousParentId,
-                                electedParentId: this.electedParentId,
-                                electedClientId: this.electedClientId,
-                                opsSinceLastReport,
-                                maxOpsSinceLastSummary,
-                            });
-                        }
-                    }
-                }
-            }
-        });
-
-        // When a summary ack comes in, reset our op seq counter.
-        this.summaryCollection.on(MessageType.SummaryAck, (op) => {
-            this.lastSummaryAckSeqForClient = op.sequenceNumber;
-        });
-
-        // Use oldest client election for unanimously and deterministically deciding
-        // which client should summarize.
-        this.clientElection.on("election", (client, sequenceNumber) => {
-            this.lastSummaryAckSeqForClient = undefined;
-            if (client === undefined && this.clientElection.eligibleCount > 0) {
-                // If no client is valid for election, reset to the oldest again.
-                // Also make extra sure not to get stuck in an infinite loop here:
-                // If there are no eligible clients, just wait until a client joins
-                // and will be auto-elected.
-                this.clientElection.resetElectedClient(sequenceNumber);
-            }
-            // Election can trigger a change in SummaryManager state.
-            this.emit("electedSummarizerChanged");
-        });
-    }
-
-    public serialize(): ISerializedElection {
-        const { electedClientId, electedParentId, electionSequenceNumber } = this.clientElection.serialize();
-        return {
-            electedClientId,
-            electedParentId,
-            electionSequenceNumber: this.lastSummaryAckSeqForClient ?? electionSequenceNumber,
-        };
-    }
-
-    public static isClientEligible(client: ITrackedClient): boolean {
-        const details = client.client.details;
-        if (details === undefined) {
-            // Very old clients back-compat
-            return true;
-        }
-        return SummarizerClientElection.clientDetailsPermitElection(details);
-    }
-
-    public static readonly clientDetailsPermitElection = (details: IClientDetails): boolean =>
-        details.capabilities.interactive || details.type === summarizerClientType;
-}

package/src/summarizerHandle.ts

@@ -1,21 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { FluidObjectHandle } from "@fluidframework/datastore";
-import { IFluidHandle } from "@fluidframework/core-interfaces";
-
-// TODO #2425 Expose Summarizer handle as FluidObjectHandle w/ tests
-export class SummarizerHandle extends FluidObjectHandle {
-    public async get(): Promise<any> {
-        throw Error("Do not try to get a summarizer object from the handle. Reference it directly.");
-    }
-
-    public attach(): void {
-        return;
-    }
-
-    public bind(handle: IFluidHandle) {
-        return;
-    }
-}

package/src/summarizerHeuristics.ts

@@ -1,222 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { Timer } from "@fluidframework/common-utils";
-import { ISummaryConfigurationHeuristics } from "./containerRuntime";
-import {
-    ISummarizeHeuristicData,
-    ISummarizeHeuristicRunner,
-    ISummarizeAttempt,
-    ISummaryHeuristicStrategy,
-} from "./summarizerTypes";
-import { SummarizeReason } from "./summaryGenerator";
-
-/** Simple implementation of class for tracking summarize heuristic data. */
-export class SummarizeHeuristicData implements ISummarizeHeuristicData {
-    protected _lastAttempt: ISummarizeAttempt;
-    public get lastAttempt(): ISummarizeAttempt {
-        return this._lastAttempt;
-    }
-
-    protected _lastSuccessfulSummary: Readonly<ISummarizeAttempt>;
-    public get lastSuccessfulSummary(): Readonly<ISummarizeAttempt> {
-        return this._lastSuccessfulSummary;
-    }
-
-    public numNonRuntimeOps: number = 0;
-    public totalOpsSize: number = 0;
-    public hasMissingOpData: boolean = false;
-
-    /**
-     * Cumulative size in bytes of all the ops at the beginning of the summarization attempt.
-     * Is used to adjust totalOpsSize appropriately after successful summarization.
-     */
-     /** */
-    private totalOpsSizeBefore: number = 0;
-
-    /**
-     * Number of system ops at beginning of attempting to summarize.
-     * Is used to adjust numSystemOps appropriately after successful summarization.
-     */
-    private numSystemOpsBefore: number = 0;
-
-    public numRuntimeOps: number = 0;
-    /**
-     * Number of non-system ops at beginning of attempting to summarize.
-     * Is used to adjust numNonSystemOps appropriately after successful summarization.
-     */
-    private numNonSystemOpsBefore: number = 0;
-
-    constructor(
-        public lastOpSequenceNumber: number,
-        /** Baseline attempt data used for comparisons with subsequent attempts/calculations. */
-        attemptBaseline: ISummarizeAttempt,
-    ) {
-        this._lastAttempt = attemptBaseline;
-        this._lastSuccessfulSummary = { ...attemptBaseline };
-    }
-
-    public updateWithLastSummaryAckInfo(lastSummary: Readonly<ISummarizeAttempt>) {
-        this._lastAttempt = lastSummary;
-        this._lastSuccessfulSummary = { ...lastSummary };
-    }
-
-    public recordAttempt(refSequenceNumber?: number) {
-        this._lastAttempt = {
-            refSequenceNumber: refSequenceNumber ?? this.lastOpSequenceNumber,
-            summaryTime: Date.now(),
-        };
-
-        this.numSystemOpsBefore = this.numNonRuntimeOps;
-        this.numNonSystemOpsBefore = this.numRuntimeOps;
-        this.totalOpsSizeBefore = this.totalOpsSize;
-    }
-
-    public markLastAttemptAsSuccessful() {
-        this._lastSuccessfulSummary = { ...this.lastAttempt };
-
-        this.numNonRuntimeOps -= this.numSystemOpsBefore;
-        this.numSystemOpsBefore = 0;
-
-        this.numRuntimeOps -= this.numNonSystemOpsBefore;
-        this.numNonSystemOpsBefore = 0;
-
-        this.totalOpsSize -= this.totalOpsSizeBefore;
-        this.totalOpsSizeBefore = 0;
-    }
-}
-
-/**
- * This class contains the heuristics for when to summarize.
- */
-export class SummarizeHeuristicRunner implements ISummarizeHeuristicRunner {
-    private readonly idleTimer: Timer | undefined;
-    private readonly runSummarize: (reason: SummarizeReason) => void;
-
-    public constructor(
-        private readonly heuristicData: ISummarizeHeuristicData,
-        private readonly configuration: ISummaryConfigurationHeuristics,
-        trySummarize: (reason: SummarizeReason) => void,
-        private readonly logger: ITelemetryLogger,
-        private readonly summarizeStrategies: ISummaryHeuristicStrategy[] = getDefaultSummaryHeuristicStrategies(),
-    ) {
-        this.idleTimer = new Timer(
-            this.idleTime,
-            () => this.runSummarize("idle"));
-
-        this.runSummarize = (reason: SummarizeReason) => {
-            this.idleTimer?.clear();
-
-            // We shouldn't attempt a summary if there are no new processed ops
-            const opsSinceLastAck = this.opsSinceLastAck;
-            if (opsSinceLastAck > 0) {
-                trySummarize(reason);
-            }
-        };
-    }
-
-    public get idleTime(): number {
-        const maxIdleTime = this.configuration.maxIdleTime;
-        const minIdleTime = this.configuration.minIdleTime;
-        const weightedNumOfOps = getWeightedNumberOfOps(
-            this.heuristicData.numRuntimeOps,
-            this.heuristicData.numNonRuntimeOps,
-            this.configuration.runtimeOpWeight,
-            this.configuration.nonRuntimeOpWeight,
-        );
-        const pToMaxOps = weightedNumOfOps * 1.0 / this.configuration.maxOps;
-
-        if (pToMaxOps >= 1) {
-            return minIdleTime;
-        }
-
-        // Return a ratioed idle time based on the percentage of ops
-        return maxIdleTime - ((maxIdleTime - minIdleTime) * pToMaxOps);
-    }
-
-    public get opsSinceLastAck(): number {
-        return this.heuristicData.lastOpSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber;
-    }
-
-    public start() {
-        this.idleTimer?.start(this.idleTime);
-    }
-
-    public run() {
-        for (const strategy of this.summarizeStrategies) {
-            if (strategy.shouldRunSummary(this.configuration, this.heuristicData)) {
-                return this.runSummarize(strategy.summarizeReason);
-            }
-        }
-
-        this.idleTimer?.restart(this.idleTime);
-    }
-
-    public shouldRunLastSummary(): boolean {
-        const opsSinceLastAck = this.opsSinceLastAck;
-        const minOpsForLastSummaryAttempt = this.configuration.minOpsForLastSummaryAttempt;
-
-        this.logger.sendTelemetryEvent({
-            eventName: "ShouldRunLastSummary",
-            opsSinceLastAck,
-            minOpsForLastSummaryAttempt,
-        });
-
-        return opsSinceLastAck >= minOpsForLastSummaryAttempt;
-    }
-
-    public dispose() {
-        this.idleTimer?.clear();
-    }
-}
-
-/** Strategy used to run a summary when it's been a while since our last successful summary */
-class MaxTimeSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
-    public readonly summarizeReason: Readonly<SummarizeReason> = "maxTime";
-
-    public shouldRunSummary(
-        configuration: ISummaryConfigurationHeuristics,
-        heuristicData: ISummarizeHeuristicData,
-    ): boolean {
-        const timeSinceLastSummary = Date.now() - heuristicData.lastSuccessfulSummary.summaryTime;
-        return timeSinceLastSummary > configuration.maxTime;
-    }
-}
-
-function getWeightedNumberOfOps(
-    runtimeOpCount: number,
-    nonRuntimeOpCount: number,
-    runtimeOpWeight: number,
-    nonRuntimeOpWeight: number,
-): number {
-    return (runtimeOpWeight * runtimeOpCount)
-         + (nonRuntimeOpWeight * nonRuntimeOpCount);
-}
-
-/** Strategy used to do a weighted analysis on the ops we've processed since the last successful summary */
-class WeightedOpsSummaryHeuristicStrategy implements ISummaryHeuristicStrategy {
-    public readonly summarizeReason: Readonly<SummarizeReason> = "maxOps";
-
-    public shouldRunSummary(
-        configuration: ISummaryConfigurationHeuristics,
-        heuristicData: ISummarizeHeuristicData,
-    ): boolean {
-        const weightedNumOfOps = getWeightedNumberOfOps(
-            heuristicData.numRuntimeOps,
-            heuristicData.numNonRuntimeOps,
-            configuration.runtimeOpWeight,
-            configuration.nonRuntimeOpWeight,
-        );
-        return weightedNumOfOps > configuration.maxOps;
-    }
-}
-
-function getDefaultSummaryHeuristicStrategies() {
-    return [
-        new MaxTimeSummaryHeuristicStrategy(),
-        new WeightedOpsSummaryHeuristicStrategy(),
-    ];
-}