Added expected errort handling

* Add sharedThroughput db tests

* Run npm commands

* Run npm format

* Fix error with adding container to shared db test

* Add changes for Load more option to work

* Remove localhost

* Add Mongo Pagination tests

* Run npm format

* Revert "Add Mongo Pagination tests"

This reverts commit 50a244e6f9.

* Minor fixes

* Fix errors

* Minor fix

* Fix tests

* Address comments

* Address comments

src/Common/ErrorHandlingUtils.ts

@@ -1,5 +1,7 @@
 import { MessageTypes } from "../Contracts/ExplorerContracts";
 import { SubscriptionType } from "../Contracts/SubscriptionType";
+import { isExpectedError } from "../Metrics/ErrorClassification";
+import { scenarioMonitor } from "../Metrics/ScenarioMonitor";
 import { userContext } from "../UserContext";
 import { ARMError } from "../Utils/arm/request";
 import { logConsoleError } from "../Utils/NotificationConsoleUtils";
@@ -31,6 +33,12 @@ export const handleError = (
 
   // checks for errors caused by firewall and sends them to portal to handle
   sendNotificationForError(errorMessage, errorCode);
+
+  // Mark expected failures for health metrics (auth, firewall, permissions, etc.)
+  // This ensures timeouts with expected failures emit healthy instead of unhealthy
+  if (isExpectedError(error)) {
+    scenarioMonitor.markExpectedFailure();
+  }
 };
 
 export const getErrorMessage = (error: string | Error = ""): string => {

src/Explorer/Controls/Settings/SettingsComponent.tsx

@@ -16,7 +16,7 @@ import {
 import { useIndexingPolicyStore } from "Explorer/Tabs/QueryTab/ResultsView";
 import { useDatabases } from "Explorer/useDatabases";
 import { isFabricNative } from "Platform/Fabric/FabricUtil";
-import { isVectorSearchEnabled } from "Utils/CapabilityUtils";
+import { isCapabilityEnabled, isVectorSearchEnabled } from "Utils/CapabilityUtils";
 import { isRunningOnPublicCloud } from "Utils/CloudUtils";
 import * as React from "react";
 import DiscardIcon from "../../../../images/discard.svg";
@@ -70,7 +70,6 @@ import {
   getMongoNotification,
   getTabTitle,
   hasDatabaseSharedThroughput,
-  isDataMaskingEnabled,
   isDirty,
   parseConflictResolutionMode,
   parseConflictResolutionProcedure,
@@ -1074,8 +1073,8 @@ export class SettingsComponent extends React.Component<SettingsComponentProps, S
 
       newCollection.fullTextPolicy = this.state.fullTextPolicy;
 
-      // Only send data masking policy if it was modified (dirty) and data masking is enabled
-      if (this.state.isDataMaskingDirty && isDataMaskingEnabled(this.collection.dataMaskingPolicy?.())) {
+      // Only send data masking policy if it was modified (dirty)
+      if (this.state.isDataMaskingDirty && isCapabilityEnabled(Constants.CapabilityNames.EnableDynamicDataMasking)) {
         newCollection.dataMaskingPolicy = this.state.dataMaskingContent;
       }
 
@@ -1464,7 +1463,15 @@ export class SettingsComponent extends React.Component<SettingsComponentProps, S
       });
     }
 
-    if (isDataMaskingEnabled(this.collection.dataMaskingPolicy?.())) {
+    // Check if DDM should be enabled
+    const shouldEnableDDM = (): boolean => {
+      const hasDataMaskingCapability = isCapabilityEnabled(Constants.CapabilityNames.EnableDynamicDataMasking);
+      const isSqlAccount = userContext.apiType === "SQL";
+
+      return isSqlAccount && hasDataMaskingCapability; // Only show for SQL accounts with DDM capability
+    };
+
+    if (shouldEnableDDM()) {
       const dataMaskingComponentProps: DataMaskingComponentProps = {
         shouldDiscardDataMasking: this.state.shouldDiscardDataMasking,
         resetShouldDiscardDataMasking: this.resetShouldDiscardDataMasking,

src/Explorer/Controls/Settings/SettingsSubComponents/DataMaskingComponent.tsx

@@ -1,10 +1,12 @@
 import { MessageBar, MessageBarType, Stack } from "@fluentui/react";
 import * as monaco from "monaco-editor";
 import * as React from "react";
+import * as Constants from "../../../../Common/Constants";
 import * as DataModels from "../../../../Contracts/DataModels";
+import { isCapabilityEnabled } from "../../../../Utils/CapabilityUtils";
 import { loadMonaco } from "../../../LazyMonaco";
 import { titleAndInputStackProps, unsavedEditorWarningMessage } from "../SettingsRenderUtils";
-import { isDataMaskingEnabled, isDirty as isContentDirty } from "../SettingsUtils";
+import { isDirty as isContentDirty } from "../SettingsUtils";
 
 export interface DataMaskingComponentProps {
   shouldDiscardDataMasking: boolean;
@@ -138,7 +140,7 @@ export class DataMaskingComponent extends React.Component<DataMaskingComponentPr
   };
 
   public render(): JSX.Element {
-    if (!isDataMaskingEnabled(this.props.dataMaskingContent)) {
+    if (!isCapabilityEnabled(Constants.CapabilityNames.EnableDynamicDataMasking)) {
       return null;
     }
 

src/Explorer/Controls/Settings/SettingsUtils.tsx

@@ -2,8 +2,6 @@ import * as Constants from "../../../Common/Constants";
 import * as DataModels from "../../../Contracts/DataModels";
 import * as ViewModels from "../../../Contracts/ViewModels";
 import { isFabricNative } from "../../../Platform/Fabric/FabricUtil";
-import { userContext } from "../../../UserContext";
-import { isCapabilityEnabled } from "../../../Utils/CapabilityUtils";
 import { MongoIndex } from "../../../Utils/arm/generatedClients/cosmos/types";
 
 const zeroValue = 0;
@@ -90,19 +88,6 @@ export const hasDatabaseSharedThroughput = (collection: ViewModels.Collection):
   return database?.isDatabaseShared() && !collection.offer();
 };
 
-export const isDataMaskingEnabled = (dataMaskingPolicy?: DataModels.DataMaskingPolicy): boolean => {
-  const isSqlAccount = userContext.apiType === "SQL";
-  if (!isSqlAccount) {
-    return false;
-  }
-
-  const hasDataMaskingCapability = isCapabilityEnabled(Constants.CapabilityNames.EnableDynamicDataMasking);
-  const hasDataMaskingPolicyFromCollection =
-    dataMaskingPolicy?.includedPaths?.length > 0 || dataMaskingPolicy?.excludedPaths?.length > 0;
-
-  return hasDataMaskingCapability || hasDataMaskingPolicyFromCollection;
-};
-
 export const parseConflictResolutionMode = (modeFromBackend: string): DataModels.ConflictResolutionMode => {
   // Backend can contain different casing as it does case-insensitive comparisson
   if (!modeFromBackend) {

src/Explorer/Controls/Settings/__snapshots__/SettingsComponent.test.tsx.snap

@@ -604,60 +604,6 @@ exports[`SettingsComponent renders 1`] = `
           />
         </Stack>
       </PivotItem>
-      <PivotItem
-        headerButtonProps={
-          {
-            "data-test": "settings-tab-header/DataMaskingTab",
-          }
-        }
-        headerText="Masking Policy (preview)"
-        itemKey="DataMaskingTab"
-        key="DataMaskingTab"
-        style={
-          {
-            "backgroundColor": "var(--colorNeutralBackground1)",
-            "color": "var(--colorNeutralForeground1)",
-            "marginTop": 20,
-          }
-        }
-      >
-        <Stack
-          styles={
-            {
-              "root": {
-                "backgroundColor": "var(--colorNeutralBackground1)",
-                "color": "var(--colorNeutralForeground1)",
-              },
-            }
-          }
-        >
-          <DataMaskingComponent
-            dataMaskingContent={
-              {
-                "excludedPaths": [
-                  "/excludedPath",
-                ],
-                "includedPaths": [],
-                "isPolicyEnabled": true,
-              }
-            }
-            dataMaskingContentBaseline={
-              {
-                "excludedPaths": [
-                  "/excludedPath",
-                ],
-                "includedPaths": [],
-                "isPolicyEnabled": true,
-              }
-            }
-            onDataMaskingContentChange={[Function]}
-            onDataMaskingDirtyChange={[Function]}
-            resetShouldDiscardDataMasking={[Function]}
-            shouldDiscardDataMasking={false}
-            validationErrors={[]}
-          />
-        </Stack>
-      </PivotItem>
       <PivotItem
         headerButtonProps={
           {

src/Main.tsx

@@ -119,6 +119,9 @@ const App = (): JSX.Element => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [explorer]);
 
+  // Track interactive phase for both ContainerCopyPanel and DivExplorer paths
+  useInteractive(MetricScenario.ApplicationLoad);
+
   if (!explorer) {
     return <LoadingExplorer />;
   }
@@ -145,7 +148,6 @@ const App = (): JSX.Element => {
 const DivExplorer: React.FC<{ explorer: Explorer }> = ({ explorer }) => {
   const isCarouselOpen = useCarousel((state) => state.shouldOpen);
   const isCopilotCarouselOpen = useCarousel((state) => state.showCopilotCarousel);
-  useInteractive(MetricScenario.ApplicationLoad);
 
   return (
     <div

src/Metrics/ErrorClassification.test.ts

@@ -0,0 +1,182 @@
+import { ARMError } from "../Utils/arm/request";
+import { isExpectedError } from "./ErrorClassification";
+
+describe("ErrorClassification", () => {
+  describe("isExpectedError", () => {
+    describe("ARMError with expected codes", () => {
+      it("returns true for AuthorizationFailed code", () => {
+        const error = new ARMError("Authorization failed");
+        error.code = "AuthorizationFailed";
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for Forbidden code", () => {
+        const error = new ARMError("Forbidden");
+        error.code = "Forbidden";
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for Unauthorized code", () => {
+        const error = new ARMError("Unauthorized");
+        error.code = "Unauthorized";
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for InvalidAuthenticationToken code", () => {
+        const error = new ARMError("Invalid token");
+        error.code = "InvalidAuthenticationToken";
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for ExpiredAuthenticationToken code", () => {
+        const error = new ARMError("Token expired");
+        error.code = "ExpiredAuthenticationToken";
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for numeric 401 code", () => {
+        const error = new ARMError("Unauthorized");
+        error.code = 401;
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for numeric 403 code", () => {
+        const error = new ARMError("Forbidden");
+        error.code = 403;
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns false for unexpected ARM error code", () => {
+        const error = new ARMError("Internal error");
+        error.code = "InternalServerError";
+        expect(isExpectedError(error)).toBe(false);
+      });
+
+      it("returns false for numeric 500 code", () => {
+        const error = new ARMError("Server error");
+        error.code = 500;
+        expect(isExpectedError(error)).toBe(false);
+      });
+    });
+
+    describe("MSAL AuthError with expected errorCodes", () => {
+      it("returns true for popup_window_error", () => {
+        const error = { errorCode: "popup_window_error", message: "Popup blocked" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for interaction_required", () => {
+        const error = { errorCode: "interaction_required", message: "User interaction required" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for user_cancelled", () => {
+        const error = { errorCode: "user_cancelled", message: "User cancelled" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for consent_required", () => {
+        const error = { errorCode: "consent_required", message: "Consent required" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for login_required", () => {
+        const error = { errorCode: "login_required", message: "Login required" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for no_account_error", () => {
+        const error = { errorCode: "no_account_error", message: "No account" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns false for unexpected MSAL error code", () => {
+        const error = { errorCode: "unknown_error", message: "Unknown" };
+        expect(isExpectedError(error)).toBe(false);
+      });
+    });
+
+    describe("HTTP status codes", () => {
+      it("returns true for error with status 401", () => {
+        const error = { status: 401, message: "Unauthorized" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for error with status 403", () => {
+        const error = { status: 403, message: "Forbidden" };
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns false for error with status 500", () => {
+        const error = { status: 500, message: "Internal Server Error" };
+        expect(isExpectedError(error)).toBe(false);
+      });
+
+      it("returns false for error with status 404", () => {
+        const error = { status: 404, message: "Not Found" };
+        expect(isExpectedError(error)).toBe(false);
+      });
+    });
+
+    describe("Firewall error message pattern", () => {
+      it("returns true for firewall error in Error message", () => {
+        const error = new Error("Request blocked by firewall");
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for IP not allowed error", () => {
+        const error = new Error("Client IP address is not allowed");
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for ip not allowed (no 'address')", () => {
+        const error = new Error("Your ip not allowed to access this resource");
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns true for string error with firewall", () => {
+        expect(isExpectedError("firewall rules prevent access")).toBe(true);
+      });
+
+      it("returns true for case-insensitive firewall match", () => {
+        const error = new Error("FIREWALL blocked request");
+        expect(isExpectedError(error)).toBe(true);
+      });
+
+      it("returns false for unrelated error message", () => {
+        const error = new Error("Database connection failed");
+        expect(isExpectedError(error)).toBe(false);
+      });
+    });
+
+    describe("Edge cases", () => {
+      it("returns false for null", () => {
+        expect(isExpectedError(null)).toBe(false);
+      });
+
+      it("returns false for undefined", () => {
+        expect(isExpectedError(undefined)).toBe(false);
+      });
+
+      it("returns false for empty object", () => {
+        expect(isExpectedError({})).toBe(false);
+      });
+
+      it("returns false for plain Error without expected patterns", () => {
+        const error = new Error("Something went wrong");
+        expect(isExpectedError(error)).toBe(false);
+      });
+
+      it("returns false for string without firewall pattern", () => {
+        expect(isExpectedError("Generic error occurred")).toBe(false);
+      });
+
+      it("handles error with multiple matching criteria", () => {
+        // ARMError with both code and firewall message
+        const error = new ARMError("Request blocked by firewall");
+        error.code = "Forbidden";
+        expect(isExpectedError(error)).toBe(true);
+      });
+    });
+  });
+});

src/Metrics/ErrorClassification.ts

@@ -0,0 +1,109 @@
+import { ARMError } from "../Utils/arm/request";
+
+/**
+ * Expected error codes that should not mark scenarios as unhealthy.
+ * These represent expected failures like auth issues, permission errors, and user actions.
+ */
+
+// ARM error codes (string)
+const EXPECTED_ARM_ERROR_CODES: Set<string> = new Set([
+  "AuthorizationFailed",
+  "Forbidden",
+  "Unauthorized",
+  "AuthenticationFailed",
+  "InvalidAuthenticationToken",
+  "ExpiredAuthenticationToken",
+  "AuthorizationPermissionMismatch",
+]);
+
+// HTTP status codes that indicate expected failures
+const EXPECTED_HTTP_STATUS_CODES: Set<number> = new Set([
+  401, // Unauthorized
+  403, // Forbidden
+]);
+
+// MSAL error codes (string)
+const EXPECTED_MSAL_ERROR_CODES: Set<string> = new Set([
+  "popup_window_error",
+  "interaction_required",
+  "user_cancelled",
+  "consent_required",
+  "login_required",
+  "no_account_error",
+  "monitor_window_timeout",
+  "empty_window_error",
+]);
+
+// Firewall error message pattern (only case where we check message content)
+const FIREWALL_ERROR_PATTERN = /firewall|ip\s*(address)?\s*(is\s*)?not\s*allowed/i;
+
+/**
+ * Interface for MSAL AuthError-like objects
+ */
+interface MsalAuthError {
+  errorCode?: string;
+}
+
+/**
+ * Interface for errors with HTTP status
+ */
+interface HttpError {
+  status?: number;
+}
+
+/**
+ * Determines if an error is an expected failure that should not mark the scenario as unhealthy.
+ *
+ * Expected failures include:
+ * - Authentication/authorization errors (user not logged in, permissions)
+ * - Firewall blocking errors
+ * - User-cancelled operations
+ *
+ * @param error - The error to classify
+ * @returns true if the error is expected and should not affect health metrics
+ */
+export function isExpectedError(error: unknown): boolean {
+  if (!error) {
+    return false;
+  }
+
+  // Check ARMError code
+  if (error instanceof ARMError && error.code !== undefined) {
+    if (typeof error.code === "string" && EXPECTED_ARM_ERROR_CODES.has(error.code)) {
+      return true;
+    }
+    if (typeof error.code === "number" && EXPECTED_HTTP_STATUS_CODES.has(error.code)) {
+      return true;
+    }
+  }
+
+  // Check for MSAL AuthError (has errorCode property)
+  const msalError = error as MsalAuthError;
+  if (msalError.errorCode && typeof msalError.errorCode === "string") {
+    if (EXPECTED_MSAL_ERROR_CODES.has(msalError.errorCode)) {
+      return true;
+    }
+  }
+
+  // Check HTTP status on generic errors
+  const httpError = error as HttpError;
+  if (httpError.status && typeof httpError.status === "number") {
+    if (EXPECTED_HTTP_STATUS_CODES.has(httpError.status)) {
+      return true;
+    }
+  }
+
+  // Check for firewall error in message (the only message-based check)
+  if (error instanceof Error && error.message) {
+    if (FIREWALL_ERROR_PATTERN.test(error.message)) {
+      return true;
+    }
+  }
+
+  // Check for string errors with firewall pattern
+  if (typeof error === "string" && FIREWALL_ERROR_PATTERN.test(error)) {
+    return true;
+  }
+
+  return false;
+}

src/Metrics/MetricEvents.ts

@@ -15,6 +15,11 @@ export const reportUnhealthy = (scenario: MetricScenario, platform: Platform, ap
   send({ platform, api, scenario, healthy: false });
 
 const send = async (event: MetricEvent): Promise<Response> => {
+  // Skip metrics emission during local development
+  if (process.env.NODE_ENV === "development") {
+    return Promise.resolve(new Response(null, { status: 200 }));
+  }
+
   const url = createUri(configContext?.PORTAL_BACKEND_ENDPOINT, RELATIVE_PATH);
   const authHeader = getAuthorizationHeader();
 

src/Metrics/ScenarioMonitor.test.ts

@@ -0,0 +1,231 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { configContext } from "../ConfigContext";
+import { updateUserContext } from "../UserContext";
+import MetricScenario, { reportHealthy, reportUnhealthy } from "./MetricEvents";
+import { ApplicationMetricPhase, CommonMetricPhase } from "./ScenarioConfig";
+import { scenarioMonitor } from "./ScenarioMonitor";
+
+// Mock the MetricEvents module
+jest.mock("./MetricEvents", () => ({
+  __esModule: true,
+  default: {
+    ApplicationLoad: "ApplicationLoad",
+    DatabaseLoad: "DatabaseLoad",
+  },
+  reportHealthy: jest.fn().mockResolvedValue({ ok: true }),
+  reportUnhealthy: jest.fn().mockResolvedValue({ ok: true }),
+}));
+
+// Mock configContext
+jest.mock("../ConfigContext", () => ({
+  configContext: {
+    platform: "Portal",
+    PORTAL_BACKEND_ENDPOINT: "https://test.portal.azure.com",
+  },
+  Platform: {
+    Portal: "Portal",
+    Hosted: "Hosted",
+    Emulator: "Emulator",
+    Fabric: "Fabric",
+  },
+}));
+
+describe("ScenarioMonitor", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Use legacy fake timers to avoid conflicts with performance API
+    jest.useFakeTimers({ legacyFakeTimers: true });
+
+    // Ensure performance mock is available (setupTests.ts sets this but fake timers may override)
+    if (typeof performance.mark !== "function") {
+      Object.defineProperty(global, "performance", {
+        writable: true,
+        configurable: true,
+        value: {
+          mark: jest.fn(),
+          measure: jest.fn(),
+          clearMarks: jest.fn(),
+          clearMeasures: jest.fn(),
+          getEntriesByName: jest.fn().mockReturnValue([{ startTime: 0 }]),
+          getEntriesByType: jest.fn().mockReturnValue([]),
+          now: jest.fn(() => Date.now()),
+          timeOrigin: Date.now(),
+        },
+      });
+    }
+
+    // Reset userContext
+    updateUserContext({
+      apiType: "SQL",
+    });
+
+    // Reset the scenario monitor to clear any previous state
+    scenarioMonitor.reset();
+  });
+
+  afterEach(() => {
+    // Reset scenarios before switching to real timers
+    scenarioMonitor.reset();
+    jest.useRealTimers();
+  });
+
+  describe("markExpectedFailure", () => {
+    it("sets hasExpectedFailure flag on active scenarios", () => {
+      // Start a scenario
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Mark expected failure
+      scenarioMonitor.markExpectedFailure();
+
+      // Let timeout fire - should emit healthy because of expected failure
+      jest.advanceTimersByTime(10000);
+
+      expect(reportHealthy).toHaveBeenCalledWith(MetricScenario.ApplicationLoad, configContext.platform, "SQL");
+      expect(reportUnhealthy).not.toHaveBeenCalled();
+    });
+
+    it("sets flag on multiple active scenarios", () => {
+      // Start two scenarios
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+      scenarioMonitor.start(MetricScenario.DatabaseLoad);
+
+      // Mark expected failure - should affect both
+      scenarioMonitor.markExpectedFailure();
+
+      // Let timeouts fire
+      jest.advanceTimersByTime(10000);
+
+      expect(reportHealthy).toHaveBeenCalledTimes(2);
+      expect(reportUnhealthy).not.toHaveBeenCalled();
+    });
+
+    it("does not affect already emitted scenarios", () => {
+      // Start scenario
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Complete all phases to emit
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, ApplicationMetricPhase.ExplorerInitialized);
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, CommonMetricPhase.Interactive);
+
+      // Now mark expected failure - should not change anything
+      scenarioMonitor.markExpectedFailure();
+
+      // Healthy was called when phases completed
+      expect(reportHealthy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("timeout behavior", () => {
+    it("emits unhealthy on timeout without expected failure", () => {
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Let timeout fire without marking expected failure
+      jest.advanceTimersByTime(10000);
+
+      expect(reportUnhealthy).toHaveBeenCalledWith(MetricScenario.ApplicationLoad, configContext.platform, "SQL");
+      expect(reportHealthy).not.toHaveBeenCalled();
+    });
+
+    it("emits healthy on timeout with expected failure", () => {
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Mark expected failure
+      scenarioMonitor.markExpectedFailure();
+
+      // Let timeout fire
+      jest.advanceTimersByTime(10000);
+
+      expect(reportHealthy).toHaveBeenCalledWith(MetricScenario.ApplicationLoad, configContext.platform, "SQL");
+      expect(reportUnhealthy).not.toHaveBeenCalled();
+    });
+
+    it("emits healthy even with partial phase completion and expected failure", () => {
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Complete one phase
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, ApplicationMetricPhase.ExplorerInitialized);
+
+      // Mark expected failure
+      scenarioMonitor.markExpectedFailure();
+
+      // Let timeout fire (Interactive phase not completed)
+      jest.advanceTimersByTime(10000);
+
+      expect(reportHealthy).toHaveBeenCalled();
+      expect(reportUnhealthy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("failPhase behavior", () => {
+    it("emits unhealthy immediately on unexpected failure", () => {
+      scenarioMonitor.start(MetricScenario.DatabaseLoad);
+
+      // Fail a phase (simulating unexpected error)
+      scenarioMonitor.failPhase(MetricScenario.DatabaseLoad, ApplicationMetricPhase.DatabasesFetched);
+
+      // Should emit unhealthy immediately, not wait for timeout
+      expect(reportUnhealthy).toHaveBeenCalledWith(MetricScenario.DatabaseLoad, configContext.platform, "SQL");
+    });
+
+    it("does not emit twice after failPhase and timeout", () => {
+      scenarioMonitor.start(MetricScenario.DatabaseLoad);
+
+      // Fail a phase
+      scenarioMonitor.failPhase(MetricScenario.DatabaseLoad, ApplicationMetricPhase.DatabasesFetched);
+
+      // Let timeout fire
+      jest.advanceTimersByTime(10000);
+
+      // Should only have emitted once (from failPhase)
+      expect(reportUnhealthy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("completePhase behavior", () => {
+    it("emits healthy when all phases complete", () => {
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Complete all required phases
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, ApplicationMetricPhase.ExplorerInitialized);
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, CommonMetricPhase.Interactive);
+
+      expect(reportHealthy).toHaveBeenCalledWith(MetricScenario.ApplicationLoad, configContext.platform, "SQL");
+    });
+
+    it("does not emit until all phases complete", () => {
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+
+      // Complete only one phase
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, ApplicationMetricPhase.ExplorerInitialized);
+
+      expect(reportHealthy).not.toHaveBeenCalled();
+      expect(reportUnhealthy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("scenario isolation", () => {
+    it("expected failure on one scenario does not affect others after completion", () => {
+      // Start both scenarios
+      scenarioMonitor.start(MetricScenario.ApplicationLoad);
+      scenarioMonitor.start(MetricScenario.DatabaseLoad);
+
+      // Complete ApplicationLoad
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, ApplicationMetricPhase.ExplorerInitialized);
+      scenarioMonitor.completePhase(MetricScenario.ApplicationLoad, CommonMetricPhase.Interactive);
+
+      // Now mark expected failure - should only affect DatabaseLoad
+      scenarioMonitor.markExpectedFailure();
+
+      // Let DatabaseLoad timeout
+      jest.advanceTimersByTime(10000);
+
+      // ApplicationLoad emitted healthy on completion
+      // DatabaseLoad emits healthy on timeout (expected failure)
+      expect(reportHealthy).toHaveBeenCalledTimes(2);
+      expect(reportUnhealthy).not.toHaveBeenCalled();
+    });
+  });
+});

src/Metrics/ScenarioMonitor.ts

@@ -21,6 +21,7 @@ interface InternalScenarioContext {
   phases: Map<MetricPhase, PhaseContext>; // Track start/end for each phase
   timeoutId?: number;
   emitted: boolean;
+  hasExpectedFailure: boolean; // Flag for expected failures (auth, firewall, etc.)
 }
 
 class ScenarioMonitor {
@@ -75,6 +76,7 @@ class ScenarioMonitor {
       failed: new Set<MetricPhase>(),
       phases: new Map<MetricPhase, PhaseContext>(),
       emitted: false,
+      hasExpectedFailure: false,
     };
 
     // Start all required phases at scenario start time
@@ -91,7 +93,11 @@ class ScenarioMonitor {
       timeoutMs: config.timeoutMs,
     });
 
-    ctx.timeoutId = window.setTimeout(() => this.emit(ctx, false, true), config.timeoutMs);
+    ctx.timeoutId = window.setTimeout(() => {
+      // If an expected failure occurred (auth, firewall, etc.), emit healthy instead of unhealthy
+      const healthy = ctx.hasExpectedFailure;
+      this.emit(ctx, healthy, true);
+    }, config.timeoutMs);
     this.contexts.set(scenario, ctx);
   }
 
@@ -175,6 +181,24 @@ class ScenarioMonitor {
     this.emit(ctx, false, false, failureSnapshot);
   }
 
+  /**
+   * Marks that an expected failure occurred (auth, firewall, permissions, etc.).
+   * When the scenario times out with this flag set, it will emit healthy instead of unhealthy.
+   * This is called automatically from handleError when an expected error is detected.
+   */
+  markExpectedFailure() {
+    // Set the flag on all active (non-emitted) scenarios
+    this.contexts.forEach((ctx) => {
+      if (!ctx.emitted) {
+        ctx.hasExpectedFailure = true;
+        traceMark(Action.MetricsScenario, {
+          event: "expected_failure_marked",
+          scenario: ctx.scenario,
+        });
+      }
+    });
+  }
+
   private tryEmitIfReady(ctx: InternalScenarioContext) {
     const allDone = ctx.config.requiredPhases.every((p) => ctx.completed.has(p));
     if (!allDone) {
@@ -247,7 +271,8 @@ class ScenarioMonitor {
     });
 
     // Call portal backend health metrics endpoint
-    if (healthy && !timedOut) {
+    // If healthy is true (either completed successfully or timeout with expected failure), report healthy
+    if (healthy) {
       reportHealthy(ctx.scenario, platform, api);
     } else {
       reportUnhealthy(ctx.scenario, platform, api);
@@ -302,6 +327,19 @@ class ScenarioMonitor {
       phaseTimings,
     };
   }
+
+  /**
+   * Reset all scenarios (for testing purposes only).
+   * Clears all active contexts and their timeouts.
+   */
+  reset() {
+    this.contexts.forEach((ctx) => {
+      if (ctx.timeoutId) {
+        clearTimeout(ctx.timeoutId);
+      }
+    });
+    this.contexts.clear();
+  }
 }
 
 export const scenarioMonitor = new ScenarioMonitor();

src/Utils/AuthorizationUtils.ts

@@ -8,6 +8,8 @@ import * as Logger from "../Common/Logger";
 import { configContext } from "../ConfigContext";
 import { DatabaseAccount } from "../Contracts/DataModels";
 import * as ViewModels from "../Contracts/ViewModels";
+import { isExpectedError } from "../Metrics/ErrorClassification";
+import { scenarioMonitor } from "../Metrics/ScenarioMonitor";
 import { trace, traceFailure } from "../Shared/Telemetry/TelemetryProcessor";
 import { UserContext, userContext } from "../UserContext";
 
@@ -127,6 +129,10 @@ export async function acquireMsalTokenForAccount(
         acquireTokenType: silent ? "silent" : "interactive",
         errorMessage: JSON.stringify(error),
       });
+      // Mark expected failure for health metrics so timeout emits healthy
+      if (isExpectedError(error)) {
+        scenarioMonitor.markExpectedFailure();
+      }
       throw error;
     }
   } else {
@@ -169,7 +175,10 @@ export async function acquireTokenWithMsal(
           acquireTokenType: "interactive",
           errorMessage: JSON.stringify(interactiveError),
         });
-
+        // Mark expected failure for health metrics so timeout emits healthy
+        if (isExpectedError(interactiveError)) {
+          scenarioMonitor.markExpectedFailure();
+        }
         throw interactiveError;
       }
     } else {
@@ -178,7 +187,10 @@ export async function acquireTokenWithMsal(
         acquireTokenType: "silent",
         errorMessage: JSON.stringify(silentError),
       });
-
+      // Mark expected failure for health metrics so timeout emits healthy
+      if (isExpectedError(silentError)) {
+        scenarioMonitor.markExpectedFailure();
+      }
       throw silentError;
     }
   }

test/fx.ts

@@ -58,7 +58,9 @@ export const defaultAccounts: Record<TestAccount, string> = {
 export const resourceGroupName = process.env.DE_TEST_RESOURCE_GROUP ?? "de-e2e-tests";
 export const subscriptionId = process.env.DE_TEST_SUBSCRIPTION_ID ?? "69e02f2d-f059-4409-9eac-97e8a276ae2c";
 export const TEST_AUTOSCALE_THROUGHPUT_RU = 1000;
+export const TEST_MANUAL_THROUGHPUT_RU = 800;
 export const TEST_AUTOSCALE_MAX_THROUGHPUT_RU_2K = 2000;
+export const TEST_AUTOSCALE_MAX_THROUGHPUT_RU_4K = 4000;
 export const TEST_MANUAL_THROUGHPUT_RU_2K = 2000;
 export const ONE_MINUTE_MS: number = 60 * 1000;
 

test/sql/scaleAndSettings/sharedThroughput.spec.ts

@@ -0,0 +1,229 @@
+import { Locator, expect, test } from "@playwright/test";
+import {
+  CommandBarButton,
+  DataExplorer,
+  ONE_MINUTE_MS,
+  TEST_AUTOSCALE_MAX_THROUGHPUT_RU_4K,
+  TEST_MANUAL_THROUGHPUT_RU,
+  TestAccount,
+} from "../../fx";
+import { TestDatabaseContext, createTestDB } from "../../testData";
+
+test.describe("Database with Shared Throughput", () => {
+  let dbContext: TestDatabaseContext = null!;
+  let explorer: DataExplorer = null!;
+  const containerId = "sharedcontainer";
+
+  // Helper methods
+  const getThroughputInput = (type: "manual" | "autopilot"): Locator => {
+    return explorer.frame.getByTestId(`${type}-throughput-input`);
+  };
+
+  test.afterEach("Delete Test Database", async () => {
+    await dbContext?.dispose();
+  });
+
+  test.describe("Manual Throughput Tests", () => {
+    test.beforeEach(async ({ page }) => {
+      explorer = await DataExplorer.open(page, TestAccount.SQL);
+    });
+
+    test("Create database with shared manual throughput and verify Scale node in UI", async () => {
+      test.setTimeout(120000); // 2 minutes timeout
+      // Create database with shared manual throughput (400 RU/s)
+      dbContext = await createTestDB({ throughput: 400 });
+
+      // Verify database node appears in the tree
+      const databaseNode = await explorer.waitForNode(dbContext.database.id);
+      expect(databaseNode).toBeDefined();
+
+      // Expand the database node to see child nodes
+      await databaseNode.expand();
+
+      // Verify that "Scale" node appears under the database
+      const scaleNode = await explorer.waitForNode(`${dbContext.database.id}/Scale`);
+      expect(scaleNode).toBeDefined();
+      await expect(scaleNode.element).toBeVisible();
+    });
+
+    test("Add container to shared database without dedicated throughput", async () => {
+      // Create database with shared manual throughput
+      dbContext = await createTestDB({ throughput: 400 });
+
+      // Wait for the database to appear in the tree
+      await explorer.waitForNode(dbContext.database.id);
+
+      // Add a container to the shared database via UI
+      const newContainerButton = await explorer.globalCommandButton("New Container");
+      await newContainerButton.click();
+
+      await explorer.whilePanelOpen(
+        "New Container",
+        async (panel, okButton) => {
+          // Select "Use existing" database
+          const useExistingRadio = panel.getByRole("radio", { name: /Use existing/i });
+          await useExistingRadio.click();
+
+          // Select the database from dropdown using the new data-testid
+          const databaseDropdown = panel.getByRole("combobox", { name: "Choose an existing database" });
+          await databaseDropdown.click();
+
+          await explorer.frame.getByRole("option", { name: dbContext.database.id }).click();
+          // Now you can target the specific database option by its data-testid
+          //await panel.getByTestId(`database-option-${dbContext.database.id}`).click();
+          // Fill container id
+          await panel.getByRole("textbox", { name: "Container id, Example Container1" }).fill(containerId);
+
+          // Fill partition key
+          await panel.getByRole("textbox", { name: "Partition key" }).fill("/pk");
+
+          // Ensure "Provision dedicated throughput" is NOT checked
+          const dedicatedThroughputCheckbox = panel.getByRole("checkbox", {
+            name: /Provision dedicated throughput for this container/i,
+          });
+
+          if (await dedicatedThroughputCheckbox.isVisible()) {
+            const isChecked = await dedicatedThroughputCheckbox.isChecked();
+            if (isChecked) {
+              await dedicatedThroughputCheckbox.uncheck();
+            }
+          }
+
+          await okButton.click();
+        },
+        { closeTimeout: 5 * ONE_MINUTE_MS },
+      );
+
+      // Verify container was created under the database
+      const containerNode = await explorer.waitForContainerNode(dbContext.database.id, containerId);
+      expect(containerNode).toBeDefined();
+    });
+
+    test("Scale shared database manual throughput", async () => {
+      // Create database with shared manual throughput (400 RU/s)
+      dbContext = await createTestDB({ throughput: 400 });
+
+      // Navigate to the scale settings by clicking the "Scale" node in the tree
+      const databaseNode = await explorer.waitForNode(dbContext.database.id);
+      await databaseNode.expand();
+      const scaleNode = await explorer.waitForNode(`${dbContext.database.id}/Scale`);
+      await scaleNode.element.click();
+
+      // Update manual throughput from 400 to 800
+      await getThroughputInput("manual").fill(TEST_MANUAL_THROUGHPUT_RU.toString());
+
+      // Save changes
+      await explorer.commandBarButton(CommandBarButton.Save).click();
+
+      // Verify success message
+      await expect(explorer.getConsoleHeaderStatus()).toContainText(
+        `Successfully updated offer for database ${dbContext.database.id}`,
+        {
+          timeout: 2 * ONE_MINUTE_MS,
+        },
+      );
+    });
+
+    test("Scale shared database from manual to autoscale", async () => {
+      // Create database with shared manual throughput (400 RU/s)
+      dbContext = await createTestDB({ throughput: 400 });
+
+      // Open database settings by clicking the "Scale" node
+      const databaseNode = await explorer.waitForNode(dbContext.database.id);
+      await databaseNode.expand();
+      const scaleNode = await explorer.waitForNode(`${dbContext.database.id}/Scale`);
+      await scaleNode.element.click();
+
+      // Switch to Autoscale
+      const autoscaleRadio = explorer.frame.getByText("Autoscale", { exact: true });
+      await autoscaleRadio.click();
+
+      // Set autoscale max throughput to 1000
+      //await getThroughputInput("autopilot").fill(TEST_AUTOSCALE_THROUGHPUT_RU.toString());
+
+      // Save changes
+      await explorer.commandBarButton(CommandBarButton.Save).click();
+
+      await expect(explorer.getConsoleHeaderStatus()).toContainText(
+        `Successfully updated offer for database ${dbContext.database.id}`,
+        {
+          timeout: 2 * ONE_MINUTE_MS,
+        },
+      );
+    });
+  });
+
+  test.describe("Autoscale Throughput Tests", () => {
+    test.beforeEach(async ({ page }) => {
+      explorer = await DataExplorer.open(page, TestAccount.SQL);
+    });
+
+    test("Create database with shared autoscale throughput and verify Scale node in UI", async () => {
+      test.setTimeout(120000); // 2 minutes timeout
+
+      // Create database with shared autoscale throughput (max 1000 RU/s)
+      dbContext = await createTestDB({ maxThroughput: 1000 });
+
+      // Verify database node appears
+      const databaseNode = await explorer.waitForNode(dbContext.database.id);
+      expect(databaseNode).toBeDefined();
+
+      // Expand the database node to see child nodes
+      await databaseNode.expand();
+
+      // Verify that "Scale" node appears under the database
+      const scaleNode = await explorer.waitForNode(`${dbContext.database.id}/Scale`);
+      expect(scaleNode).toBeDefined();
+      await expect(scaleNode.element).toBeVisible();
+    });
+
+    test("Scale shared database autoscale throughput", async () => {
+      // Create database with shared autoscale throughput (max 1000 RU/s)
+      dbContext = await createTestDB({ maxThroughput: 1000 });
+
+      // Open database settings
+      const databaseNode = await explorer.waitForNode(dbContext.database.id);
+      await databaseNode.expand();
+      const scaleNode = await explorer.waitForNode(`${dbContext.database.id}/Scale`);
+      await scaleNode.element.click();
+
+      // Update autoscale max throughput from 1000 to 4000
+      await getThroughputInput("autopilot").fill(TEST_AUTOSCALE_MAX_THROUGHPUT_RU_4K.toString());
+
+      // Save changes
+      await explorer.commandBarButton(CommandBarButton.Save).click();
+
+      // Verify success message
+      await expect(explorer.getConsoleHeaderStatus()).toContainText(
+        `Successfully updated offer for database ${dbContext.database.id}`,
+        {
+          timeout: 2 * ONE_MINUTE_MS,
+        },
+      );
+    });
+
+    test("Scale shared database from autoscale to manual", async () => {
+      // Create database with shared autoscale throughput (max 1000 RU/s)
+      dbContext = await createTestDB({ maxThroughput: 1000 });
+
+      // Open database settings
+      const databaseNode = await explorer.waitForNode(dbContext.database.id);
+      await databaseNode.expand();
+      const scaleNode = await explorer.waitForNode(`${dbContext.database.id}/Scale`);
+      await scaleNode.element.click();
+
+      // Switch to Manual
+      const manualRadio = explorer.frame.getByText("Manual", { exact: true });
+      await manualRadio.click();
+
+      // Save changes
+      await explorer.commandBarButton(CommandBarButton.Save).click();
+
+      // Verify success message
+      await expect(explorer.getConsoleHeaderStatus()).toContainText(
+        `Successfully updated offer for database ${dbContext.database.id}`,
+        { timeout: 2 * ONE_MINUTE_MS },
+      );
+    });
+  });
+});

test/testData.ts

@@ -82,6 +82,75 @@ export class TestContainerContext {
   }
 }
 
+export class TestDatabaseContext {
+  constructor(
+    public armClient: CosmosDBManagementClient,
+    public client: CosmosClient,
+    public database: Database,
+  ) {}
+
+  async dispose() {
+    await this.database.delete();
+  }
+}
+
+export interface CreateTestDBOptions {
+  throughput?: number;
+  maxThroughput?: number; // For autoscale
+}
+
+// Helper function to create ARM client and Cosmos client for SQL account
+async function createCosmosClientForSQLAccount(
+  accountType: TestAccount.SQL | TestAccount.SQLContainerCopyOnly = TestAccount.SQL,
+): Promise<{ armClient: CosmosDBManagementClient; client: CosmosClient }> {
+  const credentials = getAzureCLICredentials();
+  const adaptedCredentials = new AzureIdentityCredentialAdapter(credentials);
+  const armClient = new CosmosDBManagementClient(adaptedCredentials, subscriptionId);
+  const accountName = getAccountName(accountType);
+  const account = await armClient.databaseAccounts.get(resourceGroupName, accountName);
+
+  const clientOptions: CosmosClientOptions = {
+    endpoint: account.documentEndpoint!,
+  };
+
+  const rbacToken =
+    accountType === TestAccount.SQL
+      ? process.env.NOSQL_TESTACCOUNT_TOKEN
+      : accountType === TestAccount.SQLContainerCopyOnly
+      ? process.env.NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN
+      : "";
+
+  if (rbacToken) {
+    clientOptions.tokenProvider = async (): Promise<string> => {
+      const AUTH_PREFIX = `type=aad&ver=1.0&sig=`;
+      const authorizationToken = `${AUTH_PREFIX}${rbacToken}`;
+      return authorizationToken;
+    };
+  } else {
+    const keys = await armClient.databaseAccounts.listKeys(resourceGroupName, accountName);
+    clientOptions.key = keys.primaryMasterKey;
+  }
+
+  const client = new CosmosClient(clientOptions);
+
+  return { armClient, client };
+}
+
+export async function createTestDB(options?: CreateTestDBOptions): Promise<TestDatabaseContext> {
+  const databaseId = generateUniqueName("db");
+  const { armClient, client } = await createCosmosClientForSQLAccount();
+
+  // Create database with provisioned throughput (shared throughput)
+  // This checks the "Provision database throughput" option
+  const { database } = await client.databases.create({
+    id: databaseId,
+    throughput: options?.throughput, // Manual throughput (e.g., 400)
+    maxThroughput: options?.maxThroughput, // Autoscale max throughput (e.g., 1000)
+  });
+
+  return new TestDatabaseContext(armClient, client, database);
+}
+
 type createTestSqlContainerConfig = {
   includeTestData?: boolean;
   partitionKey?: string;
@@ -104,34 +173,7 @@ export async function createMultipleTestContainers({
   const creationPromises: Promise<TestContainerContext>[] = [];
 
   const databaseId = databaseName ? databaseName : generateUniqueName("db");
-  const credentials = getAzureCLICredentials();
-  const adaptedCredentials = new AzureIdentityCredentialAdapter(credentials);
-  const armClient = new CosmosDBManagementClient(adaptedCredentials, subscriptionId);
-  const accountName = getAccountName(accountType);
-  const account = await armClient.databaseAccounts.get(resourceGroupName, accountName);
-
-  const clientOptions: CosmosClientOptions = {
-    endpoint: account.documentEndpoint!,
-  };
-
-  const rbacToken =
-    accountType === TestAccount.SQL
-      ? process.env.NOSQL_TESTACCOUNT_TOKEN
-      : accountType === TestAccount.SQLContainerCopyOnly
-      ? process.env.NOSQL_CONTAINERCOPY_TESTACCOUNT_TOKEN
-      : "";
-  if (rbacToken) {
-    clientOptions.tokenProvider = async (): Promise<string> => {
-      const AUTH_PREFIX = `type=aad&ver=1.0&sig=`;
-      const authorizationToken = `${AUTH_PREFIX}${rbacToken}`;
-      return authorizationToken;
-    };
-  } else {
-    const keys = await armClient.databaseAccounts.listKeys(resourceGroupName, accountName);
-    clientOptions.key = keys.primaryMasterKey;
-  }
-
-  const client = new CosmosClient(clientOptions);
+  const { armClient, client } = await createCosmosClientForSQLAccount(accountType);
   const { database } = await client.databases.createIfNotExists({ id: databaseId });
 
   try {
@@ -158,29 +200,8 @@ export async function createTestSQLContainer({
 }: createTestSqlContainerConfig = {}) {
   const databaseId = databaseName ? databaseName : generateUniqueName("db");
   const containerId = "testcontainer"; // A unique container name isn't needed because the database is unique
-  const credentials = getAzureCLICredentials();
-  const adaptedCredentials = new AzureIdentityCredentialAdapter(credentials);
-  const armClient = new CosmosDBManagementClient(adaptedCredentials, subscriptionId);
-  const accountName = getAccountName(TestAccount.SQL);
-  const account = await armClient.databaseAccounts.get(resourceGroupName, accountName);
+  const { armClient, client } = await createCosmosClientForSQLAccount();
 
-  const clientOptions: CosmosClientOptions = {
-    endpoint: account.documentEndpoint!,
-  };
-
-  const nosqlAccountRbacToken = process.env.NOSQL_TESTACCOUNT_TOKEN;
-  if (nosqlAccountRbacToken) {
-    clientOptions.tokenProvider = async (): Promise<string> => {
-      const AUTH_PREFIX = `type=aad&ver=1.0&sig=`;
-      const authorizationToken = `${AUTH_PREFIX}${nosqlAccountRbacToken}`;
-      return authorizationToken;
-    };
-  } else {
-    const keys = await armClient.databaseAccounts.listKeys(resourceGroupName, accountName);
-    clientOptions.key = keys.primaryMasterKey;
-  }
-
-  const client = new CosmosClient(clientOptions);
   const { database } = await client.databases.createIfNotExists({ id: databaseId });
   try {
     const { container } = await database.containers.createIfNotExists({