Merge branch 'master' into users/nishthaahuja/searchableDropdown

* Initial plan

* Fix TypeScript compilation errors in SearchableDropdown.test.tsx

Co-authored-by: nishthaAhujaa <45535788+nishthaAhujaa@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: nishthaAhujaa <45535788+nishthaAhujaa@users.noreply.github.com>

package.json

@@ -14,7 +14,7 @@
     "@fluentui/react": "8.119.0",
     "@fluentui/react-components": "9.54.2",
     "@jupyterlab/services": "6.0.2",
-    "@jupyterlab/terminal": "3.6.8",
+    "@jupyterlab/terminal": "3.0.3",
     "@microsoft/applicationinsights-web": "2.6.1",
     "@nteract/commutable": "7.5.1",
     "@nteract/connected-components": "6.8.2",
@@ -39,13 +39,12 @@
     "@nteract/transform-plotly": "6.1.6",
     "@nteract/transform-vdom": "4.0.11",
     "@nteract/transform-vega": "7.0.6",
-    "@octokit/request": "8.4.1",
     "@octokit/rest": "17.9.2",
     "@phosphor/widgets": "1.9.3",
     "@testing-library/jest-dom": "6.4.6",
     "@types/lodash": "4.14.171",
     "@types/mkdirp": "1.0.1",
-    "@types/node-fetch": "2.6.13",
+    "@types/node-fetch": "2.5.7",
     "@xmldom/xmldom": "0.7.13",
     "@xterm/addon-fit": "0.10.0",
     "@xterm/xterm": "5.5.0",
@@ -58,7 +57,7 @@
     "copy-webpack-plugin": "11.0.0",
     "crossroads": "0.12.2",
     "css-element-queries": "1.1.1",
-    "d3": "7.9.0",
+    "d3": "7.8.5",
     "datatables.net-colreorder-dt": "1.7.0",
     "datatables.net-dt": "1.13.8",
     "date-fns": "1.29.0",
@@ -80,15 +79,11 @@
     "jquery-typeahead": "2.11.1",
     "jquery-ui-dist": "1.13.2",
     "knockout": "3.5.1",
-    "lodash": "4.17.23",
-    "lodash-es": "4.17.23",
-    "min-document": "2.19.1",
     "mkdirp": "1.0.4",
     "monaco-editor": "0.44.0",
     "ms": "2.1.3",
-    "nanoid": "3.3.8",
     "p-retry": "6.2.1",
-    "patch-package": "8.0.1",
+    "patch-package": "8.0.0",
     "plotly.js-cartesian-dist-min": "1.52.3",
     "post-robot": "10.0.42",
     "q": "1.5.1",
@@ -107,6 +102,7 @@
     "react-youtube": "9.0.1",
     "reflect-metadata": "0.1.13",
     "rx-jupyter": "5.5.12",
+    "sanitize-html": "2.3.3",
     "shell-quote": "1.7.3",
     "styled-components": "5.0.1",
     "swr": "0.4.0",
@@ -116,28 +112,15 @@
     "utility-types": "3.10.0",
     "uuid": "9.0.0",
     "web-vitals": "4.2.4",
-    "ws": "8.17.1",
-    "zustand": "3.5.0"
-  },
-  "overrides": {
-    "d3-color": "3.1.0",
-    "cross-spawn": "7.0.6",
-    "less-vars-loader": {
-      "json5": "1.0.2"
-    },
-    "trim": "0.0.3",
-    "@octokit/plugin-paginate-rest": "9.2.2",
-    "@octokit/request-error": "5.1.1",
-    "@octokit/request": "8.4.1",
-    "prismjs": "1.30.0",
-    "sanitize-html": "2.17.0"
+    "zustand": "3.5.0",
+    "ws": "8.17.1"
   },
   "devDependencies": {
-    "@babel/core": "7.29.0",
+    "@babel/core": "7.24.7",
     "@babel/preset-env": "7.24.7",
     "@babel/preset-react": "7.24.7",
     "@babel/preset-typescript": "7.24.7",
-    "@playwright/test": "1.55.1",
+    "@playwright/test": "1.49.1",
     "@testing-library/react": "11.2.3",
     "@types/applicationinsights-js": "1.0.7",
     "@types/codemirror": "0.0.56",
@@ -162,7 +145,7 @@
     "@types/react-window": "1.8.8",
     "@types/sanitize-html": "1.27.2",
     "@types/sinon": "2.3.3",
-    "@types/styled-components": "5.1.32",
+    "@types/styled-components": "5.1.1",
     "@types/underscore": "1.7.36",
     "@types/youtube-player": "5.5.6",
     "@typescript-eslint/eslint-plugin": "6.7.4",
@@ -170,7 +153,6 @@
     "@webpack-cli/serve": "2.0.5",
     "babel-jest": "29.7.0",
     "babel-loader": "8.1.0",
-    "brace-expansion": "1.1.12",
     "buffer": "5.1.0",
     "case-sensitive-paths-webpack-plugin": "2.4.0",
     "create-file-webpack": "1.0.2",
@@ -195,7 +177,6 @@
     "jest-html-loader": "1.0.0",
     "jest-react-hooks-shallow": "1.5.1",
     "jest-trx-results-processor": "3.0.2",
-    "js-yaml": "3.14.2",
     "less": "4.5.1",
     "less-loader": "11.1.3",
     "less-vars-loader": "1.1.0",
@@ -215,7 +196,7 @@
     "typescript": "4.9.5",
     "url-loader": "4.1.1",
     "wait-on": "9.0.3",
-    "webpack": "5.104.1",
+    "webpack": "5.88.2",
     "webpack-bundle-analyzer": "5.2.0",
     "webpack-cli": "5.1.4",
     "webpack-dev-server": "5.2.3",

preview/package-lock.json

@@ -10,8 +10,7 @@
       "dependencies": {
         "body-parser": "^2.2.2",
         "express": "^5.2.1",
-        "follow-redirects": "^1.15.6",
-        "http-proxy-middleware": "^3.0.5",
+        "http-proxy-middleware": "^3.0.3",
         "node": "^20.19.5",
         "node-fetch": "^2.6.1",
         "path-to-regexp": "^0.1.12"
@@ -280,15 +279,14 @@
       }
     },
     "node_modules/follow-redirects": {
-      "version": "1.15.6",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.6.tgz",
-      "integrity": "sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==",
+      "version": "1.15.3",
       "funding": [
         {
           "type": "individual",
           "url": "https://github.com/sponsors/RubenVerborgh"
         }
       ],
+      "license": "MIT",
       "engines": {
         "node": ">=4.0"
       },
@@ -416,8 +414,7 @@
     },
     "node_modules/http-proxy-middleware": {
       "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-3.0.5.tgz",
-      "integrity": "sha512-GLZZm1X38BPY4lkXA01jhwxvDoOkkXqjgVyUzVxiEK4iuRu03PZoYHhHRwxnfhQMDuaxi3vVri0YgSro/1oWqg==",
+      "license": "MIT",
       "dependencies": {
         "@types/http-proxy": "^1.17.15",
         "debug": "^4.3.6",

preview/package.json

@@ -13,8 +13,7 @@
   "dependencies": {
     "body-parser": "^2.2.2",
     "express": "^5.2.1",
-    "follow-redirects": "^1.15.6",
-    "http-proxy-middleware": "^3.0.5",
+    "http-proxy-middleware": "^3.0.3",
     "node": "^20.19.5",
     "node-fetch": "^2.6.1",
     "path-to-regexp": "^0.1.12"

src/Common/ErrorHandlingUtils.ts

@@ -1,7 +1,5 @@
 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";
@@ -33,12 +31,6 @@ 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/Common/SearchableDropdown.styles.ts

@@ -0,0 +1,78 @@
+import { IButtonStyles, IStackStyles, ITextStyles } from "@fluentui/react";
+import * as React from "react";
+
+export const getDropdownButtonStyles = (disabled: boolean): IButtonStyles => ({
+  root: {
+    width: "100%",
+    height: "32px",
+    padding: "0 28px 0 8px",
+    border: "1px solid #8a8886",
+    background: "#fff",
+    color: "#323130",
+    textAlign: "left",
+    cursor: disabled ? "not-allowed" : "pointer",
+    position: "relative",
+  },
+  flexContainer: {
+    justifyContent: "flex-start",
+  },
+  label: {
+    fontWeight: "normal",
+    fontSize: "14px",
+    textAlign: "left",
+  },
+});
+
+export const buttonLabelStyles: ITextStyles = {
+  root: {
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap",
+    display: "block",
+    textAlign: "left",
+  },
+};
+
+export const buttonWrapperStyles: React.CSSProperties = {
+  position: "relative",
+  width: "100%",
+};
+
+export const chevronStyles: React.CSSProperties = {
+  position: "absolute",
+  right: "8px",
+  top: "50%",
+  transform: "translateY(-50%)",
+  pointerEvents: "none",
+  fontSize: "12px",
+};
+
+export const calloutContentStyles: IStackStyles = {
+  root: {
+    display: "flex",
+    flexDirection: "column",
+  },
+};
+
+export const listContainerStyles: IStackStyles = {
+  root: {
+    maxHeight: "300px",
+    overflowY: "auto",
+  },
+};
+
+export const getItemStyles = (isSelected: boolean): React.CSSProperties => ({
+  padding: "8px 12px",
+  cursor: "pointer",
+  fontSize: "14px",
+  backgroundColor: isSelected ? "#e6e6e6" : "transparent",
+  textAlign: "left",
+});
+
+export const emptyMessageStyles: ITextStyles = {
+  root: {
+    padding: "8px 12px",
+    color: "#605e5c",
+    textAlign: "left",
+  },
+};

src/Common/SearchableDropdown.test.tsx

@@ -0,0 +1,200 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import "@testing-library/jest-dom";
+import React from "react";
+import { SearchableDropdown } from "./SearchableDropdown";
+
+interface TestItem {
+  id: string;
+  name: string;
+}
+
+describe("SearchableDropdown", () => {
+  const mockItems: TestItem[] = [
+    { id: "1", name: "Item One" },
+    { id: "2", name: "Item Two" },
+    { id: "3", name: "Item Three" },
+  ];
+
+  const defaultProps = {
+    label: "Test Label",
+    items: mockItems,
+    selectedItem: null as TestItem | null,
+    onSelect: jest.fn(),
+    getKey: (item: TestItem) => item.id,
+    getDisplayText: (item: TestItem) => item.name,
+    placeholder: "Select an item",
+    filterPlaceholder: "Filter items",
+    className: "test-dropdown",
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should render with label and placeholder", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+    expect(screen.getByText("Test Label")).toBeInTheDocument();
+    expect(screen.getByText("Select an item")).toBeInTheDocument();
+  });
+
+  it("should display selected item", () => {
+    const propsWithSelection = {
+      ...defaultProps,
+      selectedItem: mockItems[0],
+    };
+    render(<SearchableDropdown {...propsWithSelection} />);
+    expect(screen.getByText("Item One")).toBeInTheDocument();
+  });
+
+  it("should show 'No items found' when items array is empty", () => {
+    const propsWithEmptyItems = {
+      ...defaultProps,
+      items: [] as TestItem[],
+    };
+    render(<SearchableDropdown {...propsWithEmptyItems} />);
+    expect(screen.getByText("No Test Labels Found")).toBeInTheDocument();
+  });
+
+  it("should open dropdown when button is clicked", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+    expect(screen.getByPlaceholderText("Filter items")).toBeInTheDocument();
+  });
+
+  it("should filter items based on search text", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    const searchBox = screen.getByPlaceholderText("Filter items");
+    fireEvent.change(searchBox, { target: { value: "Two" } });
+
+    expect(screen.getByText("Item Two")).toBeInTheDocument();
+    expect(screen.queryByText("Item One")).not.toBeInTheDocument();
+    expect(screen.queryByText("Item Three")).not.toBeInTheDocument();
+  });
+
+  it("should call onSelect when an item is clicked", () => {
+    const onSelectMock = jest.fn();
+    const propsWithMock = {
+      ...defaultProps,
+      onSelect: onSelectMock,
+    };
+    render(<SearchableDropdown {...propsWithMock} />);
+
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    const item = screen.getByText("Item Two");
+    fireEvent.click(item);
+
+    expect(onSelectMock).toHaveBeenCalledWith(mockItems[1]);
+  });
+
+  it("should close dropdown after selecting an item", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    expect(screen.getByPlaceholderText("Filter items")).toBeInTheDocument();
+
+    const item = screen.getByText("Item One");
+    fireEvent.click(item);
+
+    expect(screen.queryByPlaceholderText("Filter items")).not.toBeInTheDocument();
+  });
+
+  it("should disable button when disabled prop is true", () => {
+    const propsWithDisabled = {
+      ...defaultProps,
+      disabled: true,
+    };
+    render(<SearchableDropdown {...propsWithDisabled} />);
+
+    const button = screen.getByRole("button");
+    expect(button).toBeDisabled();
+  });
+
+  it("should not open dropdown when disabled", () => {
+    const propsWithDisabled = {
+      ...defaultProps,
+      disabled: true,
+    };
+    render(<SearchableDropdown {...propsWithDisabled} />);
+
+    const button = screen.getByRole("button");
+    fireEvent.click(button);
+
+    expect(screen.queryByPlaceholderText("Filter items")).not.toBeInTheDocument();
+  });
+
+  it("should show 'No items found' when search yields no results", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    const searchBox = screen.getByPlaceholderText("Filter items");
+    fireEvent.change(searchBox, { target: { value: "Nonexistent" } });
+
+    expect(screen.getByText("No items found")).toBeInTheDocument();
+  });
+
+  it("should handle case-insensitive filtering", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    const searchBox = screen.getByPlaceholderText("Filter items");
+    fireEvent.change(searchBox, { target: { value: "two" } });
+
+    expect(screen.getByText("Item Two")).toBeInTheDocument();
+    expect(screen.queryByText("Item One")).not.toBeInTheDocument();
+  });
+
+  it("should clear filter text when dropdown is closed and reopened", () => {
+    render(<SearchableDropdown {...defaultProps} />);
+
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    const searchBox = screen.getByPlaceholderText("Filter items");
+    fireEvent.change(searchBox, { target: { value: "Two" } });
+
+    // Close dropdown by selecting an item
+    const item = screen.getByText("Item Two");
+    fireEvent.click(item);
+
+    // Reopen dropdown
+    fireEvent.click(button);
+
+    // Filter text should be cleared
+    const reopenedSearchBox = screen.getByPlaceholderText("Filter items");
+    expect(reopenedSearchBox).toHaveValue("");
+  });
+
+  it("should use custom placeholder text", () => {
+    const propsWithCustomPlaceholder = {
+      ...defaultProps,
+      placeholder: "Choose an option",
+    };
+    render(<SearchableDropdown {...propsWithCustomPlaceholder} />);
+    expect(screen.getByText("Choose an option")).toBeInTheDocument();
+  });
+
+  it("should use custom filter placeholder text", () => {
+    const propsWithCustomFilterPlaceholder = {
+      ...defaultProps,
+      filterPlaceholder: "Search here",
+    };
+    render(<SearchableDropdown {...propsWithCustomFilterPlaceholder} />);
+
+    const button = screen.getByText("Select an item");
+    fireEvent.click(button);
+
+    expect(screen.getByPlaceholderText("Search here")).toBeInTheDocument();
+  });
+});

src/Common/SearchableDropdown.tsx

@@ -0,0 +1,158 @@
+import {
+  Callout,
+  DefaultButton,
+  DirectionalHint,
+  Icon,
+  ISearchBoxStyles,
+  Label,
+  SearchBox,
+  Stack,
+  Text,
+} from "@fluentui/react";
+import * as React from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
+import {
+  buttonLabelStyles,
+  buttonWrapperStyles,
+  calloutContentStyles,
+  chevronStyles,
+  emptyMessageStyles,
+  getDropdownButtonStyles,
+  getItemStyles,
+  listContainerStyles,
+} from "./SearchableDropdown.styles";
+
+interface SearchableDropdownProps<T> {
+  label: string;
+  items: T[];
+  selectedItem: T | null;
+  onSelect: (item: T) => void;
+  getKey: (item: T) => string;
+  getDisplayText: (item: T) => string;
+  placeholder?: string;
+  filterPlaceholder?: string;
+  className?: string;
+  disabled?: boolean;
+  onDismiss?: () => void;
+  searchBoxStyles?: Partial<ISearchBoxStyles>;
+}
+
+export const SearchableDropdown = <T,>({
+  label,
+  items,
+  selectedItem,
+  onSelect,
+  getKey,
+  getDisplayText,
+  placeholder = "Select an item",
+  filterPlaceholder = "Filter items",
+  className,
+  disabled = false,
+  onDismiss,
+  searchBoxStyles: customSearchBoxStyles,
+}: SearchableDropdownProps<T>): React.ReactElement => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [filterText, setFilterText] = useState("");
+  const buttonRef = useRef<HTMLDivElement>(null);
+
+  const closeDropdown = useCallback(() => {
+    setIsOpen(false);
+    setFilterText("");
+  }, []);
+
+  const filteredItems = useMemo(
+    () => items?.filter((item) => getDisplayText(item).toLowerCase().includes(filterText.toLowerCase())),
+    [items, filterText, getDisplayText],
+  );
+
+  const handleDismiss = useCallback(() => {
+    closeDropdown();
+    onDismiss?.();
+  }, [closeDropdown, onDismiss]);
+
+  const handleButtonClick = useCallback(() => {
+    if (disabled) {
+      return;
+    }
+
+    setIsOpen(!isOpen);
+  }, [isOpen, disabled]);
+
+  const handleSelect = useCallback(
+    (item: T) => {
+      onSelect(item);
+      closeDropdown();
+    },
+    [onSelect, closeDropdown],
+  );
+
+  const buttonLabel = selectedItem
+    ? getDisplayText(selectedItem)
+    : items?.length === 0
+    ? `No ${label}s Found`
+    : placeholder;
+
+  const buttonId = `${className}-button`;
+  const buttonStyles = getDropdownButtonStyles(disabled);
+
+  return (
+    <Stack>
+      <Label htmlFor={buttonId}>{label}</Label>
+      <div ref={buttonRef} style={buttonWrapperStyles}>
+        <DefaultButton
+          id={buttonId}
+          className={className}
+          onClick={handleButtonClick}
+          styles={buttonStyles}
+          disabled={disabled}
+        >
+          <Text styles={buttonLabelStyles}>{buttonLabel}</Text>
+        </DefaultButton>
+        <Icon iconName="ChevronDown" style={chevronStyles} />
+      </div>
+      {isOpen && (
+        <Callout
+          target={buttonRef.current}
+          onDismiss={handleDismiss}
+          directionalHint={DirectionalHint.bottomLeftEdge}
+          isBeakVisible={false}
+          gapSpace={0}
+          setInitialFocus
+        >
+          <Stack styles={calloutContentStyles} style={{ width: buttonRef.current?.offsetWidth || 300 }}>
+            <SearchBox
+              placeholder={filterPlaceholder}
+              value={filterText}
+              onChange={(_, newValue) => setFilterText(newValue || "")}
+              styles={customSearchBoxStyles}
+              showIcon={true}
+            />
+            <Stack styles={listContainerStyles}>
+              {filteredItems && filteredItems.length > 0 ? (
+                filteredItems.map((item) => {
+                  const key = getKey(item);
+                  const isSelected = selectedItem ? getKey(selectedItem) === key : false;
+                  return (
+                    <div
+                      key={key}
+                      onClick={() => handleSelect(item)}
+                      style={getItemStyles(isSelected)}
+                      onMouseEnter={(e) => (e.currentTarget.style.backgroundColor = "#f3f2f1")}
+                      onMouseLeave={(e) =>
+                        (e.currentTarget.style.backgroundColor = isSelected ? "#e6e6e6" : "transparent")
+                      }
+                    >
+                      <Text>{getDisplayText(item)}</Text>
+                    </div>
+                  );
+                })
+              ) : (
+                <Text styles={emptyMessageStyles}>No items found</Text>
+              )}
+            </Stack>
+          </Stack>
+        </Callout>
+      )}
+    </Stack>
+  );
+};

src/Common/dataAccess/queryDocumentsPage.ts

@@ -6,7 +6,7 @@ import { MinimalQueryIterator, nextPage } from "../IteratorUtilities";
 
 // Redact sensitive information from BadRequest errors with specific codes
 export const redactSyntaxErrorMessage = (error: unknown): unknown => {
-  const codesToRedact = ["SC1001", "SC2001", "SC1010"];
+  const codesToRedact = ["SC1001", "SC2001"];
 
   try {
     // Handle error objects with a message property

src/ConfigContext.ts

@@ -77,8 +77,6 @@ let configContext: Readonly<ConfigContext> = {
     `^https:\\/\\/.*\\.fabric\\.microsoft\\.com$`,
     `^https:\\/\\/.*\\.powerbi\\.com$`,
     `^https:\\/\\/dataexplorer-preview\\.azurewebsites\\.net$`,
-    `^https:\\/\\/explorer\\.cosmos\\.sovcloud-api\\.fr$`,
-    `^https:\\/\\/portal\\.sovcloud-azure\\.fr$`,
   ], // Webpack injects this at build time
   gitSha: process.env.GIT_SHA,
   hostedExplorerURL: "https://cosmos.azure.com/",

src/Explorer/DataSamples/ContainerSampleGenerator.ts

@@ -113,7 +113,7 @@ export class ContainerSampleGenerator {
               ? await createMongoDocument(collection.databaseId, collection, shardKey, doc)
               : await createDocument(collection, doc);
           } catch (error) {
-            NotificationConsoleUtils.logConsoleError(error instanceof Error ? error.message : String(error));
+            NotificationConsoleUtils.logConsoleError(error);
           }
         }),
       );

src/Explorer/Menus/NotificationConsole/NotificationConsoleComponent.tsx

@@ -329,10 +329,7 @@ export class NotificationConsoleComponent extends React.Component<
   }
 
   private static extractHeaderStatus(consoleData: ConsoleData) {
-    if (!consoleData?.message || typeof consoleData.message !== "string") {
-      return undefined;
-    }
-    return consoleData.message.split(":\n")[0];
+    return consoleData?.message.split(":\n")[0];
   }
 
   private onConsoleWasExpanded = (): void => {

src/Main.tsx

@@ -119,9 +119,6 @@ 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, !!config);
-
   if (!explorer) {
     return <LoadingExplorer />;
   }
@@ -148,6 +145,7 @@ 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

@@ -1,182 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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,11 +15,6 @@ 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

@@ -1,231 +0,0 @@
-/**
- * @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,7 +21,6 @@ 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 {
@@ -56,13 +55,6 @@ class ScenarioMonitor {
     });
   }
 
-  private devLog(msg: string) {
-    if (process.env.NODE_ENV === "development") {
-      // eslint-disable-next-line no-console
-      console.log(`[Metrics] ${msg}`);
-    }
-  }
-
   start(scenario: MetricScenario) {
     if (this.contexts.has(scenario)) {
       return;
@@ -83,7 +75,6 @@ class ScenarioMonitor {
       failed: new Set<MetricPhase>(),
       phases: new Map<MetricPhase, PhaseContext>(),
       emitted: false,
-      hasExpectedFailure: false,
     };
 
     // Start all required phases at scenario start time
@@ -93,10 +84,6 @@ class ScenarioMonitor {
       ctx.phases.set(phase, { startMarkName: phaseStartMarkName });
     });
 
-    this.devLog(
-      `scenario_start: ${scenario} | phases=${config.requiredPhases.join(", ")} | timeout=${config.timeoutMs}ms`,
-    );
-
     traceMark(Action.MetricsScenario, {
       event: "scenario_start",
       scenario,
@@ -104,11 +91,7 @@ class ScenarioMonitor {
       timeoutMs: 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);
+    ctx.timeoutId = window.setTimeout(() => this.emit(ctx, false, true), config.timeoutMs);
     this.contexts.set(scenario, ctx);
   }
 
@@ -147,12 +130,6 @@ class ScenarioMonitor {
     const endTimeISO = endEntry ? new Date(navigationStart + endEntry.startTime).toISOString() : undefined;
     const durationMs = startEntry && endEntry ? endEntry.startTime - startEntry.startTime : undefined;
 
-    this.devLog(
-      `phase_complete: ${scenario}.${phase} | ${
-        durationMs !== null && durationMs !== undefined ? `${Math.round(durationMs)}ms` : "?"
-      } | ${ctx.completed.size}/${ctx.config.requiredPhases.length} phases`,
-    );
-
     traceSuccess(Action.MetricsScenario, {
       event: "phase_complete",
       scenario,
@@ -172,13 +149,6 @@ class ScenarioMonitor {
       return;
     }
 
-    // If an expected failure was flagged (auth, firewall, etc.), treat as success.
-    if (ctx.hasExpectedFailure) {
-      this.devLog(`phase_fail: ${scenario}.${phase} — expected failure, completing as healthy`);
-      this.completePhase(scenario, phase);
-      return;
-    }
-
     // Mark the explicitly failed phase
     performance.mark(`scenario_${scenario}_${phase}_failed`);
     ctx.failed.add(phase);
@@ -193,12 +163,6 @@ class ScenarioMonitor {
     // Build a snapshot with failure info
     const failureSnapshot = this.buildSnapshot(ctx, { final: false, timedOut: false });
 
-    this.devLog(
-      `phase_fail: ${scenario}.${phase} | failed=[${Array.from(ctx.failed).join(", ")}] | completed=[${Array.from(
-        ctx.completed,
-      ).join(", ")}]`,
-    );
-
     traceFailure(Action.MetricsScenario, {
       event: "phase_fail",
       scenario,
@@ -207,28 +171,10 @@ class ScenarioMonitor {
       completedPhases: Array.from(ctx.completed).join(","),
     });
 
-    // Emit unhealthy immediately for unexpected failures
+    // Emit unhealthy immediately
     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) {
@@ -300,22 +246,8 @@ class ScenarioMonitor {
       ttfb: finalSnapshot.vitals?.ttfb,
     });
 
-    this.devLog(
-      `scenario_end: ${ctx.scenario} | ${healthy ? "healthy" : "unhealthy"} | ${
-        timedOut ? "timed out" : `${Math.round(finalSnapshot.durationMs)}ms`
-      } | ${JSON.stringify({
-        completedPhases: finalSnapshot.completed.join(", "),
-        failedPhases: finalSnapshot.failedPhases?.join(", ") || "none",
-        platform,
-        api,
-        phaseTimings: finalSnapshot.phaseTimings,
-        vitals: finalSnapshot.vitals,
-      })}`,
-    );
-
     // Call portal backend health metrics endpoint
-    // If healthy is true (either completed successfully or timeout with expected failure), report healthy
-    if (healthy) {
+    if (healthy && !timedOut) {
       reportHealthy(ctx.scenario, platform, api);
     } else {
       reportUnhealthy(ctx.scenario, platform, api);
@@ -370,19 +302,6 @@ 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/Metrics/useMetricPhases.ts

@@ -7,18 +7,14 @@ import { ApplicationMetricPhase, CommonMetricPhase } from "./ScenarioConfig";
  * Hook to automatically complete the Interactive phase when the component becomes interactive.
  * Uses requestAnimationFrame to complete after the browser has painted.
  */
-export function useInteractive(scenario: MetricScenario, enabled = true) {
+export function useInteractive(scenario: MetricScenario) {
   const { completePhase } = useMetricScenario();
 
   React.useEffect(() => {
-    if (!enabled) {
-      return undefined;
-    }
-    const id = requestAnimationFrame(() => {
+    requestAnimationFrame(() => {
       completePhase(scenario, CommonMetricPhase.Interactive);
     });
-    return () => cancelAnimationFrame(id);
-  }, [scenario, completePhase, enabled]);
+  }, [scenario, completePhase]);
 }
 
 /**

src/Platform/Fabric/FabricUtil.ts

@@ -37,7 +37,7 @@ const requestFabricToken = async (): Promise<void> => {
 
     scheduleRefreshFabricToken();
   } catch (error) {
-    logConsoleError(error instanceof Error ? error.message : String(error));
+    logConsoleError(error as string);
     throw error;
   } finally {
     lastRequestTimestamp = undefined;

src/Platform/Hosted/Components/AccountSwitcher.test.tsx

@@ -1,12 +1,12 @@
 jest.mock("../../../hooks/useSubscriptions");
 jest.mock("../../../hooks/useDatabaseAccounts");
-import React from "react";
-import { render, fireEvent, screen } from "@testing-library/react";
 import "@testing-library/jest-dom";
-import { AccountSwitcher } from "./AccountSwitcher";
-import { useSubscriptions } from "../../../hooks/useSubscriptions";
-import { useDatabaseAccounts } from "../../../hooks/useDatabaseAccounts";
+import { fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
 import { DatabaseAccount, Subscription } from "../../../Contracts/DataModels";
+import { useDatabaseAccounts } from "../../../hooks/useDatabaseAccounts";
+import { useSubscriptions } from "../../../hooks/useSubscriptions";
+import { AccountSwitcher } from "./AccountSwitcher";
 
 it("calls setAccount from parent component", () => {
   const armToken = "fakeToken";
@@ -25,7 +25,7 @@ it("calls setAccount from parent component", () => {
   expect(screen.getByLabelText("Subscription")).toHaveTextContent("Select a Subscription");
   fireEvent.click(screen.getByText("Select a Subscription"));
   fireEvent.click(screen.getByText(subscriptions[0].displayName));
-  expect(screen.getByLabelText("Cosmos DB Account Name")).toHaveTextContent("Select an Account");
+  expect(screen.getByLabelText("Cosmos DB Account")).toHaveTextContent("Select an Account");
   fireEvent.click(screen.getByText("Select an Account"));
   fireEvent.click(screen.getByText(accounts[0].name));
   expect(setDatabaseAccount).toHaveBeenCalledWith(accounts[0]);

src/Platform/Hosted/Components/SwitchAccount.tsx

@@ -1,6 +1,6 @@
-import { Dropdown } from "@fluentui/react";
 import * as React from "react";
 import { FunctionComponent } from "react";
+import { SearchableDropdown } from "../../../Common/SearchableDropdown";
 import { DatabaseAccount } from "../../../Contracts/DataModels";
 
 interface Props {
@@ -17,23 +17,18 @@ export const SwitchAccount: FunctionComponent<Props> = ({
   dismissMenu,
 }: Props) => {
   return (
-    <Dropdown
-      label="Cosmos DB Account Name"
+    <SearchableDropdown<DatabaseAccount>
+      label="Cosmos DB Account"
+      items={accounts}
+      selectedItem={selectedAccount}
+      onSelect={(account) => setSelectedAccountName(account.name)}
+      getKey={(account) => account.name}
+      getDisplayText={(account) => account.name}
+      placeholder="Select an Account"
+      filterPlaceholder="Search by Account name"
       className="accountSwitchAccountDropdown"
-      options={accounts?.map((account) => ({
-        key: account.name,
-        text: account.name,
-        data: account,
-      }))}
-      onChange={(_, option) => {
-        setSelectedAccountName(String(option?.key));
-        dismissMenu();
-      }}
-      defaultSelectedKey={selectedAccount?.name}
-      placeholder={accounts && accounts.length === 0 ? "No Accounts Found" : "Select an Account"}
-      styles={{
-        callout: "accountSwitchAccountDropdownMenu",
-      }}
+      disabled={!accounts || accounts.length === 0}
+      onDismiss={dismissMenu}
     />
   );
 };

src/Platform/Hosted/Components/SwitchSubscription.tsx

@@ -1,6 +1,6 @@
-import { Dropdown } from "@fluentui/react";
 import * as React from "react";
 import { FunctionComponent } from "react";
+import { SearchableDropdown } from "../../../Common/SearchableDropdown";
 import { Subscription } from "../../../Contracts/DataModels";
 
 interface Props {
@@ -15,24 +15,16 @@ export const SwitchSubscription: FunctionComponent<Props> = ({
   selectedSubscription,
 }: Props) => {
   return (
-    <Dropdown
+    <SearchableDropdown<Subscription>
       label="Subscription"
+      items={subscriptions}
+      selectedItem={selectedSubscription}
+      onSelect={(sub) => setSelectedSubscriptionId(sub.subscriptionId)}
+      getKey={(sub) => sub.subscriptionId}
+      getDisplayText={(sub) => sub.displayName}
+      placeholder="Select a Subscription"
+      filterPlaceholder="Search by Subscription name"
       className="accountSwitchSubscriptionDropdown"
-      options={subscriptions?.map((sub) => {
-        return {
-          key: sub.subscriptionId,
-          text: sub.displayName,
-          data: sub,
-        };
-      })}
-      onChange={(_, option) => {
-        setSelectedSubscriptionId(String(option?.key));
-      }}
-      defaultSelectedKey={selectedSubscription?.subscriptionId}
-      placeholder={subscriptions && subscriptions.length === 0 ? "No Subscriptions Found" : "Select a Subscription"}
-      styles={{
-        callout: "accountSwitchSubscriptionDropdownMenu",
-      }}
     />
   );
 };

src/Utils/AuthorizationUtils.ts

@@ -8,8 +8,6 @@ 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";
 
@@ -129,10 +127,6 @@ 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 {
@@ -175,10 +169,7 @@ 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 {
@@ -187,10 +178,7 @@ 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

@@ -250,7 +250,7 @@ class TreeNode {
       // Try three times to wait for the node to expand.
       for (let i = 0; i < RETRY_COUNT; i++) {
         try {
-          await tree.waitFor({ state: "visible", timeout: 30000 });
+          await tree.waitFor({ state: "visible" });
           // The tree has expanded, let's get out of here
           return true;
         } catch {

test/sql/containercopy/offlineMigration.spec.ts

@@ -9,10 +9,9 @@ import {
   TestAccount,
   waitForApiResponse,
 } from "../../fx";
-import { createMultipleTestContainers, TestContainerContext } from "../../testData";
+import { createMultipleTestContainers } from "../../testData";
 
 test.describe("Container Copy - Offline Migration", () => {
-  let contexts: TestContainerContext[];
   let page: Page;
   let wrapper: Locator;
   let panel: Locator;
@@ -23,7 +22,7 @@ test.describe("Container Copy - Offline Migration", () => {
   let expectedCopyJobNameInitial: string;
 
   test.beforeEach("Setup for offline migration test", async ({ browser }) => {
-    contexts = await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
+    await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
 
     page = await browser.newPage();
     ({ wrapper, frame } = await ContainerCopy.open(page, TestAccount.SQLContainerCopyOnly));
@@ -34,7 +33,6 @@ test.describe("Container Copy - Offline Migration", () => {
   test.afterEach("Cleanup after offline migration test", async () => {
     await page.unroute(/.*/, (route) => route.continue());
     await page.close();
-    await Promise.all(contexts.map((context) => context?.dispose()));
   });
 
   test("Successfully create and manage offline migration copy job", async () => {

test/sql/containercopy/onlineMigration.spec.ts

@@ -7,10 +7,9 @@ import {
   TestAccount,
   waitForApiResponse,
 } from "../../fx";
-import { createMultipleTestContainers, TestContainerContext } from "../../testData";
+import { createMultipleTestContainers } from "../../testData";
 
 test.describe("Container Copy - Online Migration", () => {
-  let contexts: TestContainerContext[];
   let page: Page;
   let wrapper: Locator;
   let panel: Locator;
@@ -18,7 +17,7 @@ test.describe("Container Copy - Online Migration", () => {
   let targetAccountName: string;
 
   test.beforeEach("Setup for online migration test", async ({ browser }) => {
-    contexts = await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
+    await createMultipleTestContainers({ accountType: TestAccount.SQLContainerCopyOnly, containerCount: 2 });
 
     page = await browser.newPage();
     ({ wrapper, frame } = await ContainerCopy.open(page, TestAccount.SQLContainerCopyOnly));
@@ -28,7 +27,6 @@ test.describe("Container Copy - Online Migration", () => {
   test.afterEach("Cleanup after online migration test", async () => {
     await page.unroute(/.*/, (route) => route.continue());
     await page.close();
-    await Promise.all(contexts.map((context) => context?.dispose()));
   });
 
   test("Successfully create and manage online migration copy job", async () => {

test/testData.ts

@@ -1,13 +1,5 @@
 import { CosmosDBManagementClient } from "@azure/arm-cosmosdb";
-import {
-  BulkOperationType,
-  Container,
-  CosmosClient,
-  CosmosClientOptions,
-  Database,
-  ErrorResponse,
-  JSONObject,
-} from "@azure/cosmos";
+import { BulkOperationType, Container, CosmosClient, CosmosClientOptions, Database, JSONObject } from "@azure/cosmos";
 import { Buffer } from "node:buffer";
 import { webcrypto } from "node:crypto";
 import {
@@ -86,14 +78,7 @@ export class TestContainerContext {
   ) {}
 
   async dispose() {
-    try {
-      await this.database.delete();
-    } catch (error) {
-      if (error instanceof ErrorResponse && error.code === 404) {
-        return; // Resource already deleted, ignore
-      }
-      throw error; // Re-throw other errors
-    }
+    await this.database.delete();
   }
 }
 

utils/deployment-status/package-lock.json

@@ -11,7 +11,7 @@
       "dependencies": {
         "chalk": "^4.1.0",
         "moment": "^2.30.1",
-        "node-fetch": "^3.3.2"
+        "node-fetch": "^2.6.1"
       }
     },
     "node_modules/@types/color-name": {
@@ -65,47 +65,6 @@
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
     },
-    "node_modules/data-uri-to-buffer": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
-      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
-      "engines": {
-        "node": ">= 12"
-      }
-    },
-    "node_modules/fetch-blob": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
-      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/jimmywarting"
-        },
-        {
-          "type": "paypal",
-          "url": "https://paypal.me/jimmywarting"
-        }
-      ],
-      "dependencies": {
-        "node-domexception": "^1.0.0",
-        "web-streams-polyfill": "^3.0.3"
-      },
-      "engines": {
-        "node": "^12.20 || >= 14.13"
-      }
-    },
-    "node_modules/formdata-polyfill": {
-      "version": "4.0.10",
-      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
-      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
-      "dependencies": {
-        "fetch-blob": "^3.1.2"
-      },
-      "engines": {
-        "node": ">=12.20.0"
-      }
-    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -122,40 +81,12 @@
         "node": "*"
       }
     },
-    "node_modules/node-domexception": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
-      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
-      "deprecated": "Use your platform's native DOMException instead",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/jimmywarting"
-        },
-        {
-          "type": "github",
-          "url": "https://paypal.me/jimmywarting"
-        }
-      ],
-      "engines": {
-        "node": ">=10.5.0"
-      }
-    },
     "node_modules/node-fetch": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
-      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
-      "dependencies": {
-        "data-uri-to-buffer": "^4.0.0",
-        "fetch-blob": "^3.1.4",
-        "formdata-polyfill": "^4.0.10"
-      },
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.1.tgz",
+      "integrity": "sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw==",
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/node-fetch"
+        "node": "4.x || >=6.0.0"
       }
     },
     "node_modules/supports-color": {
@@ -168,14 +99,6 @@
       "engines": {
         "node": ">=8"
       }
-    },
-    "node_modules/web-streams-polyfill": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
-      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
-      "engines": {
-        "node": ">= 8"
-      }
     }
   }
 }

utils/deployment-status/package.json

@@ -12,6 +12,6 @@
   "dependencies": {
     "chalk": "^4.1.0",
     "moment": "^2.30.1",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^2.6.1"
   }
 }