@fluidframework/container-runtime 1.0.1 → 1.1.0

package/src/connectionTelemetry.ts

@@ -19,17 +19,17 @@ import { assert, performance } from "@fluidframework/common-utils";
 export const latencyThreshold = 5000;
 
 // Phases in OpPerfTelemetry:
-// 1.	Op sits in a buffer in DeltaManager (DM) queue, then in outbound queue for some time.
-// 	 - Note: We do not differentiate these two today in telemetry, but first one is due to batches,
-//           second one might happen due to outbound queue being paused.
-// 2.	Op is sent to service and back.
-// 3.	Op sits in inbound queue.
+// 1.	Op is added to DeltaManager (DM) buffer.
+// 2.	Op is sent to service (op leaves outbound queue).
+// 	 - Note: We do not know for sure when op is sent, we only track when it is added to outbound queue.
+//     If outbound queue is paused, time queue is paused is counted as network time.
+// 3.	Op received from service back (pushed to inbound queue).
 // 4.	Op is processed.
 interface IOpPerfTelemetryProperties {
     /** Measure time between (1) and (2) - Measure time outbound op is sitting in queue due to active batch */
-    durationOutboundQueue: number;
-    /** Measure time between (2) and (3) - Track how long op is sitting in inbound queue until it is processed */
-    durationInboundQueue: number;
+    durationOutboundBatching: number; // was durationOutboundQueue in previous versions
+    /** Measure time between (2) and (3) - Track how long it took for op to be acked by service */
+    durationNetwork: number; // was durationInboundQueue
     /** Measure time between (3) and (4) - Time between DM's inbound "push" event until DM's "op" event */
     durationInboundToProcessing: number;
     /** Length of the DeltaManager's inbound queue at the time of the DM's inbound "push" event (3) */
@@ -41,11 +41,11 @@ interface IOpPerfTelemetryProperties {
  */
  interface IOpPerfTimings {
      /** Starting time for (1) */
-    opStartTimeForLatencyStatistics: number;
+    submitOpEventTime: number;
      /** Starting time for (2) */
-     opStartTimeSittingInboundQueue: number;
+     outboundPushEventTime: number;
      /** Starting time for (3) */
-     opStartTimeInboundPushEvent: number;
+     inboundPushEventTime: number;
 }
 
 class OpPerfTelemetry {
@@ -102,26 +102,27 @@ class OpPerfTelemetry {
             this.opPerfData = {};
             this.connectionOpSeqNumber = undefined;
             this.firstConnection = false;
+            this.pongCount = 0;
         });
 
         this.deltaManager.outbound.on("push", (messages) => {
             for (const msg of messages) {
                 if (msg.type === MessageType.Operation &&
                     this.clientSequenceNumberForLatencyStatistics === msg.clientSequenceNumber) {
-                    assert(this.opProcessingTimes.opStartTimeSittingInboundQueue === undefined,
-                        0x2c8 /* "opStartTimeSittingInboundQueue should be undefined" */);
-                    assert(this.opPerfData.durationInboundQueue === undefined,
-                        0x2c9 /* "durationInboundQueue should be undefined" */);
-                    this.opProcessingTimes.opStartTimeSittingInboundQueue = Date.now();
+                    assert(this.opProcessingTimes.outboundPushEventTime === undefined,
+                        0x2c8 /* "outboundPushEventTime should be undefined" */);
+                    assert(this.opPerfData.durationNetwork === undefined,
+                        0x2c9 /* "durationNetwork should be undefined" */);
+                    this.opProcessingTimes.outboundPushEventTime = Date.now();
 
-                    assert(this.opPerfData.durationOutboundQueue === undefined,
-                        0x2ca /* "durationOutboundQueue should be undefined" */);
+                    assert(this.opPerfData.durationOutboundBatching === undefined,
+                        0x2ca /* "durationOutboundBatching should be undefined" */);
 
-                    assert(this.opProcessingTimes.opStartTimeForLatencyStatistics !== undefined,
-                        0x2cb /* "opStartTimeForLatencyStatistics should be undefined" */);
+                    assert(this.opProcessingTimes.submitOpEventTime !== undefined,
+                        0x2cb /* "submitOpEventTime should be undefined" */);
 
-                    this.opPerfData.durationOutboundQueue = this.opProcessingTimes.opStartTimeSittingInboundQueue
-                        - this.opProcessingTimes.opStartTimeForLatencyStatistics;
+                    this.opPerfData.durationOutboundBatching = this.opProcessingTimes.outboundPushEventTime
+                        - this.opProcessingTimes.submitOpEventTime;
                 }
             }
         });
@@ -130,11 +131,11 @@ class OpPerfTelemetry {
             if (this.clientId === message.clientId &&
                 message.type === MessageType.Operation &&
                 this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber &&
-                this.opProcessingTimes.opStartTimeSittingInboundQueue !== undefined) {
-                this.opProcessingTimes.opStartTimeInboundPushEvent = Date.now();
-                this.opPerfData.durationInboundQueue = this.opProcessingTimes.opStartTimeInboundPushEvent
-                                     - this.opProcessingTimes.opStartTimeSittingInboundQueue;
-                this.opProcessingTimes.opStartTimeSittingInboundQueue = undefined;
+                this.opProcessingTimes.outboundPushEventTime !== undefined) {
+                this.opProcessingTimes.inboundPushEventTime = Date.now();
+                this.opPerfData.durationNetwork = this.opProcessingTimes.inboundPushEventTime
+                                     - this.opProcessingTimes.outboundPushEventTime;
+                this.opProcessingTimes.outboundPushEventTime = undefined;
                 this.opPerfData.lengthInboundQueue = this.deltaManager.inbound.length;
             }
         });
@@ -173,12 +174,11 @@ class OpPerfTelemetry {
     private recordPingTime(latency: number) {
         this.pingLatency = latency;
         // logging one in every 1000 pongs, including the first time, if it is a "write" client.
-        if (this.pongCount % 1000 === 0 && this.deltaManager.active) {
+        if (this.pongCount % 100 === 0 && this.deltaManager.active) {
             this.logger.sendPerformanceEvent({
                 eventName: "DeltaLatency",
                 duration: latency,
             });
-            this.pongCount = 0;
         }
         this.pongCount++;
     }
@@ -187,11 +187,11 @@ class OpPerfTelemetry {
         // start with first client op and measure latency every 500 client ops
         if (this.clientSequenceNumberForLatencyStatistics === undefined &&
             message.clientSequenceNumber % 500 === 1) {
-            assert(this.opProcessingTimes.opStartTimeSittingInboundQueue === undefined,
+            assert(this.opProcessingTimes.outboundPushEventTime === undefined,
                 0x2cc /* "OpTimeSittingInboundQueue should be undefined" */);
-            assert(this.opPerfData.durationInboundQueue === undefined,
-                0x2cd /* "durationInboundQueue should be undefined" */);
-            this.opProcessingTimes.opStartTimeForLatencyStatistics = Date.now();
+            assert(this.opPerfData.durationNetwork === undefined,
+                0x2cd /* "durationNetwork should be undefined" */);
+            this.opProcessingTimes.submitOpEventTime = Date.now();
             this.clientSequenceNumberForLatencyStatistics = message.clientSequenceNumber;
         }
     }
@@ -223,16 +223,16 @@ class OpPerfTelemetry {
 
         if (this.clientId === message.clientId &&
             this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber) {
-            assert(this.opProcessingTimes.opStartTimeForLatencyStatistics !== undefined,
+            assert(this.opProcessingTimes.submitOpEventTime !== undefined,
                 0x120 /* "Undefined latency statistics (op send time)" */);
             const currentTime = Date.now();
 
-            if (this.opProcessingTimes.opStartTimeInboundPushEvent !== undefined) {
+            if (this.opProcessingTimes.inboundPushEventTime !== undefined) {
                 this.opPerfData.durationInboundToProcessing = currentTime
-                - this.opProcessingTimes.opStartTimeInboundPushEvent;
+                - this.opProcessingTimes.inboundPushEventTime;
             }
 
-            const duration = currentTime - this.opProcessingTimes.opStartTimeForLatencyStatistics;
+            const duration = currentTime - this.opProcessingTimes.submitOpEventTime;
 
             // One of the core expectations for Fluid service is to be fast.
             // When it's not the case, we want to learn about it and be able to investigate, so
@@ -258,6 +258,27 @@ class OpPerfTelemetry {
         }
     }
 }
+export interface IPerfSignalReport {
+    /**
+     * Identifier for the signal being submitted in order to
+     * allow collection of data around the roundtrip of signal messages.
+     */
+    signalSequenceNumber: number;
+    /**
+     * Number of signals that were expected but not received.
+     */
+    signalsLost: number;
+
+    /**
+     * Timestamp before submitting the signal we will trace.
+     */
+    signalTimestamp: number;
+
+    /**
+     * Expected Signal Sequence to be received.
+     */
+    trackingSignalSequenceNumber: number | undefined;
+}
 
 export function ReportOpPerfTelemetry(
     clientId: string | undefined,

package/src/containerRuntime.ts

@@ -49,6 +49,7 @@ import { DriverHeader, IDocumentStorageService, ISummaryContext } from "@fluidfr
 import { readAndParse } from "@fluidframework/driver-utils";
 import {
     DataCorruptionError,
+    DataProcessingError,
     GenericError,
     UsageError,
     extractSafePropertiesFromMessage,
@@ -108,7 +109,11 @@ import { FluidDataStoreRegistry } from "./dataStoreRegistry";
 import { Summarizer } from "./summarizer";
 import { SummaryManager } from "./summaryManager";
 import { DeltaScheduler } from "./deltaScheduler";
-import { ReportOpPerfTelemetry, latencyThreshold } from "./connectionTelemetry";
+import {
+    ReportOpPerfTelemetry,
+    latencyThreshold,
+    IPerfSignalReport,
+} from "./connectionTelemetry";
 import { IPendingLocalState, PendingStateManager } from "./pendingStateManager";
 import { pkgVersion } from "./packageVersion";
 import { BlobManager, IBlobManagerLoadInfo } from "./blobManager";
@@ -221,7 +226,7 @@ export interface ISummaryConfigurationHeuristics extends ISummaryBaseConfigurati
     /**
      * Defines the maximum allowed time in between summarizations.
      */
-     idleTime: number;
+    idleTime: number;
     /**
      * Defines the maximum allowed time, since the last received Ack,  before running the summary
      * with reason maxTime.
@@ -231,9 +236,9 @@ export interface ISummaryConfigurationHeuristics extends ISummaryBaseConfigurati
      * Defines the maximum number of Ops, since the last received Ack, that can be allowed
      * before running the summary with reason maxOps.
      */
-     maxOps: number;
+    maxOps: number;
     /**
-     * Defnines the minimum number of Ops, since the last received Ack, that can be allowed
+     * Defines the minimum number of Ops, since the last received Ack, that can be allowed
      * before running the last summary.
      */
     minOpsForLastSummaryAttempt: number;
@@ -334,7 +339,7 @@ export interface ISummaryRuntimeOptions {
      * @deprecated - use `summaryConfigOverrides.maxOpsSinceLastSummary` instead.
      * Defaults to 7000 ops
      */
-     maxOpsSinceLastSummary?: number;
+    maxOpsSinceLastSummary?: number;
 
      /**
      * @deprecated - use `summaryConfigOverrides.summarizerClientElection` instead.
@@ -606,7 +611,7 @@ class ScheduleManagerCore {
 
     private resumeQueue(startBatch: number, messageEndBatch: ISequencedDocumentMessage) {
         const endBatch = messageEndBatch.sequenceNumber;
-        const duration = performance.now() - this.timePaused;
+        const duration = this.localPaused ? (performance.now() - this.timePaused) : undefined;
 
         this.batchCount++;
         if (this.batchCount % 1000 === 1) {
@@ -629,7 +634,7 @@ class ScheduleManagerCore {
         this.localPaused = false;
 
         // Random round number - we want to know when batch waiting paused op processing.
-        if (duration > latencyThreshold) {
+        if (duration !== undefined && duration > latencyThreshold) {
             this.logger.sendErrorEvent({
                 eventName: "MaxBatchWaitTimeExceeded",
                 duration,
@@ -891,7 +896,8 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
         // Verify summary runtime sequence number matches protocol sequence number.
         const runtimeSequenceNumber = metadata?.message?.sequenceNumber;
-        if (runtimeSequenceNumber !== undefined) {
+        // When we load with pending state, we reuse an old snapshot so we don't expect these numbers to match
+        if (!pendingRuntimeState && runtimeSequenceNumber !== undefined) {
             const protocolSequenceNumber = context.deltaManager.initialSequenceNumber;
             // Unless bypass is explicitly set, then take action when sequence numbers mismatch.
             if (loadSequenceNumberVerification !== "bypass" && runtimeSequenceNumber !== protocolSequenceNumber) {
@@ -1044,6 +1050,14 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private dirtyContainer: boolean;
     private emitDirtyDocumentEvent = true;
 
+    private readonly defaultTelemetrySignalSampleCount = 100;
+    private _perfSignalData: IPerfSignalReport = {
+        signalsLost: 0,
+        signalSequenceNumber: 0,
+        signalTimestamp: 0,
+        trackingSignalSequenceNumber: undefined,
+    };
+
     /**
      * Summarizer is responsible for coordinating when to send generate and send summaries.
      * It is the main entry point for summary work.
@@ -1201,18 +1215,18 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         const pendingRuntimeState = context.pendingLocalState as IPendingRuntimeState | undefined;
         const baseSnapshot: ISnapshotTree | undefined = pendingRuntimeState?.baseSnapshot ?? context.baseSnapshot;
 
-        this.garbageCollector = GarbageCollector.create(
-            this,
-            this.runtimeOptions.gcOptions,
-            (nodePath: string) => this.getGCNodePackagePath(nodePath),
-            () => this.messageAtLastSummary?.timestamp,
+        this.garbageCollector = GarbageCollector.create({
+            runtime: this,
+            gcOptions: this.runtimeOptions.gcOptions,
             baseSnapshot,
-            async <T>(id: string) => readAndParse<T>(this.storage, id),
-            this.mc.logger,
+            baseLogger: this.mc.logger,
             existing,
             metadata,
-            this.context.clientDetails.type === summarizerClientType,
-        );
+            isSummarizerClient: this.context.clientDetails.type === summarizerClientType,
+            getNodePackagePath: (nodePath: string) => this.getGCNodePackagePath(nodePath),
+            getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
+            readAndParseBlob: async <T>(id: string) => readAndParse<T>(this.storage, id),
+        });
 
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
         this.summarizerNode = createRootSummarizerNodeWithGC(
@@ -1557,11 +1571,17 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         }
     }
 
+    private internalId(maybeAlias: string): string {
+        return this.dataStores.aliases().get(maybeAlias) ?? maybeAlias;
+    }
+
     private async getDataStoreFromRequest(id: string, request: IRequest): Promise<IFluidRouter> {
         const wait = typeof request.headers?.[RuntimeHeaders.wait] === "boolean"
             ? request.headers?.[RuntimeHeaders.wait]
             : true;
-        const dataStoreContext = await this.dataStores.getDataStore(id, wait);
+
+        const internalId = this.internalId(id);
+        const dataStoreContext = await this.dataStores.getDataStore(internalId, wait);
 
         /**
          * If GC should run and this an external app request with "externalRequest" header, we need to return
@@ -1743,15 +1763,24 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         const reconnection = changeOfState && connected;
         this._connected = connected;
 
+        if (!connected) {
+            this._perfSignalData.signalsLost = 0;
+            this._perfSignalData.signalTimestamp = 0;
+            this._perfSignalData.trackingSignalSequenceNumber = undefined;
+        }
+
         if (reconnection) {
             this.consecutiveReconnects++;
 
             if (!this.shouldContinueReconnecting()) {
-                this.closeFn(new GenericError(
+                this.closeFn(
                     // pre-0.58 error message: MaxReconnectsWithNoProgress
-                    "Runtime detected too many reconnects with no progress syncing local ops",
-                    undefined, // error
-                    {
+                    DataProcessingError.create(
+                        "Runtime detected too many reconnects with no progress syncing local ops",
+                        "setConnectionState",
+                        undefined,
+                       {
+                        dataLoss: 1,
                         attempts: this.consecutiveReconnects,
                         pendingMessages: this.pendingStateManager.pendingMessagesCount,
                     }));
@@ -1853,6 +1882,22 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         this.dataStores.processAliasMessage(message, localOpMetadata, local);
     }
 
+    /**
+     * Emits the Signal event and update the perf signal data.
+     * @param clientSignalSequenceNumber - is the client signal sequence number to be uploaded.
+     */
+    private sendSignalTelemetryEvent(clientSignalSequenceNumber: number) {
+        const duration = Date.now() - this._perfSignalData.signalTimestamp;
+        this.logger.sendPerformanceEvent({
+            eventName: "SignalLatency",
+            duration,
+            signalsLost: this._perfSignalData.signalsLost,
+        });
+
+        this._perfSignalData.signalsLost = 0;
+        this._perfSignalData.signalTimestamp = 0;
+    }
+
     public processSignal(message: ISignalMessage, local: boolean) {
         const envelope = message.content as ISignalEnvelope;
         const transformed: IInboundSignalMessage = {
@@ -1861,6 +1906,26 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             type: envelope.contents.type,
         };
 
+        // Only collect signal telemetry for messages sent by the current client.
+        if (message.clientId === this.clientId && this.connected) {
+            // Check to see if the signal was lost.
+            if (this._perfSignalData.trackingSignalSequenceNumber !== undefined &&
+                envelope.clientSignalSequenceNumber > this._perfSignalData.trackingSignalSequenceNumber) {
+                this._perfSignalData.signalsLost++;
+                this._perfSignalData.trackingSignalSequenceNumber = undefined;
+                this.logger.sendErrorEvent({
+                    eventName: "SignalLost",
+                    type: envelope.contents.type,
+                    signalsLost: this._perfSignalData.signalsLost,
+                    trackingSequenceNumber: this._perfSignalData.trackingSignalSequenceNumber,
+                    clientSignalSequenceNumber: envelope.clientSignalSequenceNumber,
+                });
+            } else if (envelope.clientSignalSequenceNumber === this._perfSignalData.trackingSignalSequenceNumber) {
+                this.sendSignalTelemetryEvent(envelope.clientSignalSequenceNumber);
+                this._perfSignalData.trackingSignalSequenceNumber = undefined;
+            }
+        }
+
         if (envelope.address === undefined) {
             // No address indicates a container signal message.
             this.emit("signal", transformed, local);
@@ -1871,7 +1936,8 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     }
 
     public async getRootDataStore(id: string, wait = true): Promise<IFluidRouter> {
-        const context = await this.dataStores.getDataStore(id, wait);
+        const internalId = this.internalId(id);
+        const context = await this.dataStores.getDataStore(internalId, wait);
         assert(await context.isRoot(), 0x12b /* "did not get root data store" */);
         return context.realize();
     }
@@ -2001,7 +2067,13 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         return fluidDataStore;
     }
 
+    /**
+     * @deprecated - will be removed in an upcoming release. See #9660.
+     */
     public async createRootDataStore(pkg: string | string[], rootDataStoreId: string): Promise<IFluidRouter> {
+        if (rootDataStoreId.includes("/")) {
+            throw new UsageError(`Id cannot contain slashes: '${rootDataStoreId}'`);
+        }
         return this._aliasingEnabled === true ?
             this.createAndAliasDataStore(pkg, rootDataStoreId) :
             this.createRootDataStoreLegacy(pkg, rootDataStoreId);
@@ -2046,6 +2118,9 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     public createDetachedRootDataStore(
         pkg: Readonly<string[]>,
         rootDataStoreId: string): IFluidDataStoreContextDetached {
+        if (rootDataStoreId.includes("/")) {
+            throw new UsageError(`Id cannot contain slashes: '${rootDataStoreId}'`);
+        }
         return this.dataStores.createDetachedDataStoreCore(pkg, true, rootDataStoreId);
     }
 
@@ -2143,6 +2218,24 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         return true;
     }
 
+    private createNewSignalEnvelope(address: string | undefined, type: string, content: any): ISignalEnvelope {
+        const newSequenceNumber = ++this._perfSignalData.signalSequenceNumber;
+        const newEnvelope: ISignalEnvelope = {
+            address,
+            clientSignalSequenceNumber: newSequenceNumber,
+            contents: { type, content },
+        };
+
+        // We should not track any signals in case we already have a tracking number.
+        if (newSequenceNumber % this.defaultTelemetrySignalSampleCount === 1 &&
+            this._perfSignalData.trackingSignalSequenceNumber === undefined) {
+            this._perfSignalData.signalTimestamp = Date.now();
+            this._perfSignalData.trackingSignalSequenceNumber = newSequenceNumber;
+        }
+
+        return newEnvelope;
+    }
+
     /**
      * Submits the signal to be sent to other clients.
      * @param type - Type of the signal.
@@ -2150,13 +2243,13 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
      */
     public submitSignal(type: string, content: any) {
         this.verifyNotClosed();
-        const envelope: ISignalEnvelope = { address: undefined, contents: { type, content } };
+        const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content);
         return this.context.submitSignalFn(envelope);
     }
 
     public submitDataStoreSignal(address: string, type: string, content: any) {
-        const envelope: ISignalEnvelope = { address, contents: { type, content } };
-        return this.context.submitSignalFn(envelope);
+        const envelope = this.createNewSignalEnvelope(address, type, content);
+         return this.context.submitSignalFn(envelope);
     }
 
     public setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void {

package/src/dataStore.ts

@@ -4,8 +4,9 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { unreachableCase } from "@fluidframework/common-utils";
+import { assert, unreachableCase } from "@fluidframework/common-utils";
 import { AttachState } from "@fluidframework/container-definitions";
+import { UsageError } from "@fluidframework/container-utils";
 import { IRequest, IResponse } from "@fluidframework/core-interfaces";
 import { AliasResult, IDataStore, IFluidDataStoreChannel } from "@fluidframework/runtime-definitions";
 import { TelemetryDataTag } from "@fluidframework/telemetry-utils";
@@ -53,16 +54,27 @@ enum AliasState {
 class DataStore implements IDataStore {
     private aliasState: AliasState = AliasState.None;
     private alias: string | undefined;
+    private aliasResult: Promise<AliasResult> | undefined;
 
     async trySetAlias(alias: string): Promise<AliasResult> {
+        if (alias.includes("/")) {
+            throw new UsageError(`The alias cannot contain slashes: '${alias}'`);
+        }
+
         switch (this.aliasState) {
-            // If we're already aliasing, throw an exception
+            // If we're already aliasing, check if it's for the same value and return
+            // the stored promise, otherwise return 'AlreadyAliased'
             case AliasState.Aliasing:
-                return "Aliasing";
+                assert(this.aliasResult !== undefined,
+                    0x316 /* There should be a cached promise of in-progress aliasing */);
+                await this.aliasResult;
+                return this.alias === alias ? "Success" : "AlreadyAliased";
+
             // If this datastore is already aliased, return true only if this
             // is a repeated call for the same alias
             case AliasState.Aliased:
                 return this.alias === alias ? "Success" : "AlreadyAliased";
+
             // There is no current or past alias operation for this datastore,
             // it is safe to continue execution
             case AliasState.None: break;
@@ -70,6 +82,11 @@ class DataStore implements IDataStore {
         }
 
         this.aliasState = AliasState.Aliasing;
+        this.aliasResult = this.trySetAliasInternal(alias);
+        return this.aliasResult;
+    }
+
+    async trySetAliasInternal(alias: string): Promise<AliasResult> {
         const message: IDataStoreAliasMessage = {
             internalId: this.internalId,
             alias,
@@ -85,7 +102,7 @@ class DataStore implements IDataStore {
 
         if (this.runtime.attachState === AttachState.Detached) {
             const localResult = this.datastores.processAliasMessageCore(message);
-            // Explicitly Lock-out future attempts of aliasing,
+            // Explicitly lock-out future attempts of aliasing,
             // regardless of result
             this.aliasState = AliasState.Aliased;
             return localResult ? "Success" : "Conflict";

package/src/dataStoreRegistry.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+import { UsageError } from "@fluidframework/container-utils";
 import {
     FluidDataStoreRegistryEntry,
     IFluidDataStoreRegistry,
@@ -14,7 +15,13 @@ export class FluidDataStoreRegistry implements IFluidDataStoreRegistry {
     public get IFluidDataStoreRegistry() { return this; }
 
     constructor(namedEntries: NamedFluidDataStoreRegistryEntries) {
-        this.map = new Map(namedEntries);
+        this.map = new Map();
+        for (const entry of namedEntries) {
+            if (this.map.has(entry[0])) {
+                throw new UsageError("Duplicate entry names exist");
+            }
+            this.map.set(entry[0], entry[1]);
+        }
     }
 
     public async get(name: string): Promise<FluidDataStoreRegistryEntry | undefined> {

package/src/dataStores.ts

@@ -34,7 +34,7 @@ import {
      responseToException,
      SummaryTreeBuilder,
 } from "@fluidframework/runtime-utils";
-import { ChildLogger, TelemetryDataTag } from "@fluidframework/telemetry-utils";
+import { ChildLogger, LoggingError, TelemetryDataTag } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { BlobCacheStorageService, buildSnapshotTree } from "@fluidframework/driver-utils";
 import { assert, Lazy, LazyPromise } from "@fluidframework/common-utils";
@@ -145,7 +145,7 @@ export class DataStores implements IDisposable {
                 });
             } else {
                 if (typeof value !== "object") {
-                    throw new Error("Snapshot should be there to load from!!");
+                    throw new LoggingError("Snapshot should be there to load from!!");
                 }
                 const snapshotTree = value;
                 dataStoreContext = new LocalFluidDataStoreContext({
@@ -329,6 +329,8 @@ export class DataStores implements IDisposable {
         pkg: Readonly<string[]>,
         isRoot: boolean,
         id = uuid()): IFluidDataStoreContextDetached {
+        assert(!id.includes("/"), 0x30c /* Id cannot contain slashes */);
+
         const context = new LocalDetachedFluidDataStoreContext({
             id,
             pkg,
@@ -350,6 +352,7 @@ export class DataStores implements IDisposable {
     }
 
     public _createFluidDataStoreContext(pkg: string[], id: string, isRoot: boolean, props?: any) {
+        assert(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
         const context = new LocalFluidDataStoreContext({
             id,
             pkg,
@@ -418,9 +421,7 @@ export class DataStores implements IDisposable {
     }
 
     public async getDataStore(id: string, wait: boolean): Promise<FluidDataStoreContext> {
-        const internalId = this.aliasMap.get(id) ?? id;
-
-        const context = await this.contexts.getBoundOrRemoted(internalId, wait);
+        const context = await this.contexts.getBoundOrRemoted(id, wait);
         if (context === undefined) {
             // The requested data store does not exits. Throw a 404 response exception.
             const request = { url: id };