@oneuptime/common 11.7.2 → 11.7.4

package/Types/Permission.ts

@@ -1199,6 +1199,11 @@ enum Permission {
   EditNetworkSiteType = "EditNetworkSiteType",
   ReadNetworkSiteType = "ReadNetworkSiteType",
 
+  CreateRecommendationDismissal = "CreateRecommendationDismissal",
+  DeleteRecommendationDismissal = "DeleteRecommendationDismissal",
+  EditRecommendationDismissal = "EditRecommendationDismissal",
+  ReadRecommendationDismissal = "ReadRecommendationDismissal",
+
   CreateNetworkEndpoint = "CreateNetworkEndpoint",
   DeleteNetworkEndpoint = "DeleteNetworkEndpoint",
   EditNetworkEndpoint = "EditNetworkEndpoint",
@@ -7704,6 +7709,46 @@ export class PermissionHelper {
         isRolePermission: false,
         group: PermissionGroup.Monitor,
       },
+      {
+        permission: Permission.CreateRecommendationDismissal,
+        title: "Create Recommendation Dismissal",
+        description:
+          "This permission can dismiss recommendations in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.DeleteRecommendationDismissal,
+        title: "Delete Recommendation Dismissal",
+        description:
+          "This permission can restore dismissed recommendations of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.EditRecommendationDismissal,
+        title: "Edit Recommendation Dismissal",
+        description:
+          "This permission can edit dismissed recommendations of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.ReadRecommendationDismissal,
+        title: "Read Recommendation Dismissal",
+        description:
+          "This permission can read dismissed recommendations of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
       {
         permission: Permission.CreateNetworkEndpoint,
         title: "Create Network Endpoint",

package/Types/Recommendation/RecommendationType.ts

@@ -0,0 +1,20 @@
+/*
+ * The kinds of recommendation OneUptime can surface.
+ *
+ * Recommendations are suggestions OneUptime derives from telemetry it already
+ * has — "you have a Kubernetes cluster reporting HPA metrics but nothing
+ * watching whether an HPA is pinned at max replicas". Today the only kind is
+ * `Monitor` (create this monitor), but the surrounding machinery — the
+ * dismissal table, the side-menu count, the page shell — is deliberately keyed
+ * on this enum rather than on monitors, so a second kind (dashboards, cost
+ * savings, retention policies) needs no schema change and no new page.
+ *
+ * The values ARE persisted, in `RecommendationDismissal.recommendationType`.
+ * Renaming a member orphans every dismissal recorded under the old value, so
+ * treat these strings as a migration surface.
+ */
+enum RecommendationType {
+  Monitor = "Monitor",
+}
+
+export default RecommendationType;

package/Types/Runbook/RunbookExecutionDeadline.ts

@@ -0,0 +1,129 @@
+/*
+ * When a runbook execution stops being anybody's responsibility.
+ *
+ * An execution runs inside a single queue job on one Worker. If that Worker
+ * dies mid-step and the job is never redelivered — Redis lost it, the stall
+ * budget ran out, the handler threw somewhere unrecoverable — the row stays
+ * Running with nobody advancing it. Nothing else in the system would ever
+ * change it, so the reconciler needs a defensible answer to "has this been
+ * abandoned?".
+ *
+ * The answer is derived from the step that is currently Running: it cannot
+ * legitimately outlive the claim + execution window its author configured, so
+ * anything past that window plus a grace margin is abandoned. Deriving it per
+ * execution (rather than picking one global timeout) matters now that a step
+ * may be configured for anything from one second to one hour — a single
+ * threshold would either kill live hour-long restores or leave a one-second
+ * step hanging for an hour.
+ */
+
+import {
+  BashStepConfig,
+  HttpRequestStepConfig,
+  JavaScriptStepConfig,
+  RunbookStep,
+} from "./RunbookStep";
+import { RunbookStepExecutionState } from "./RunbookStepExecution";
+import RunbookStepExecutionStatus from "./RunbookStepExecutionStatus";
+import RunbookStepType from "./RunbookStepType";
+import {
+  MAX_STEP_EXECUTION_TIMEOUT_IN_MS,
+  resolveAgentClaimTimeoutInMs,
+  resolveStepExecutionTimeoutInMs,
+} from "./RunbookStepTimeout";
+
+/*
+ * Margin on top of a step's own window before the execution is declared
+ * abandoned. The Worker running the step gives up at claim + execution + 5s
+ * and then writes the failure itself, so this only has to outlast that write —
+ * five minutes leaves room for a slow database or a Worker that is briefly
+ * paused, and keeps the reconciler from racing a run that is still healthy.
+ */
+export const STUCK_EXECUTION_GRACE_IN_MS: number = 5 * 60 * 1000;
+
+/*
+ * Allowance for a step type whose runtime the author cannot bound — today
+ * that is the AI step, which runs as long as the model provider takes. The
+ * longest configurable step window is the least surprising ceiling to borrow.
+ */
+export const UNBOUNDED_STEP_ALLOWANCE_IN_MS: number =
+  MAX_STEP_EXECUTION_TIMEOUT_IN_MS;
+
+/*
+ * The longest a single step can legitimately occupy its Worker. Agent steps
+ * spend the claim window waiting for an agent to pick the job up and the
+ * execution window actually running, so they get both.
+ */
+export function getStepMaxRuntimeInMs(step: RunbookStep): number {
+  switch (step.type) {
+    case RunbookStepType.Bash:
+    case RunbookStepType.JavaScript: {
+      const config: BashStepConfig | JavaScriptStepConfig = step.config as
+        | BashStepConfig
+        | JavaScriptStepConfig;
+      return (
+        resolveAgentClaimTimeoutInMs(config.claimTimeoutInMs) +
+        resolveStepExecutionTimeoutInMs(config.timeoutInMs)
+      );
+    }
+
+    case RunbookStepType.HttpRequest: {
+      const config: HttpRequestStepConfig =
+        step.config as HttpRequestStepConfig;
+      return resolveStepExecutionTimeoutInMs(config.timeoutInMs);
+    }
+
+    /*
+     * Manual steps park the execution as WaitingForManualStep rather than
+     * Running, so one found Running is a torn write, not a wait. It gets no
+     * allowance — the grace margin alone decides.
+     */
+    case RunbookStepType.Manual:
+      return 0;
+
+    default:
+      return UNBOUNDED_STEP_ALLOWANCE_IN_MS;
+  }
+}
+
+/*
+ * Deadline for an execution currently in the Running state.
+ *
+ * Anchored on the running step's own startedAt where possible. Two fallbacks
+ * use the execution's updatedAt instead:
+ *
+ *  - A step is Running but carries no usable startedAt. The state machine
+ *    stamps startedAt and persists in the same write, so updatedAt is the same
+ *    instant; the step still gets its full allowance.
+ *  - No step is Running at all. The Worker died between steps, so nothing is
+ *    executing and no allowance is owed — only the grace margin.
+ */
+export function getRunningExecutionDeadline(data: {
+  stepExecutions: Array<RunbookStepExecutionState>;
+  executionUpdatedAt: Date;
+}): Date {
+  const runningStep: RunbookStepExecutionState | undefined =
+    data.stepExecutions.find((stepExecution: RunbookStepExecutionState) => {
+      return stepExecution.status === RunbookStepExecutionStatus.Running;
+    });
+
+  if (!runningStep) {
+    return new Date(
+      data.executionUpdatedAt.getTime() + STUCK_EXECUTION_GRACE_IN_MS,
+    );
+  }
+
+  const startedAtMs: number = runningStep.startedAt
+    ? new Date(runningStep.startedAt).getTime()
+    : NaN;
+
+  const anchorMs: number = isFinite(startedAtMs)
+    ? startedAtMs
+    : data.executionUpdatedAt.getTime();
+
+  return new Date(
+    anchorMs +
+      getStepMaxRuntimeInMs(runningStep.step) +
+      STUCK_EXECUTION_GRACE_IN_MS,
+  );
+}

package/Types/Runbook/RunbookStepTimeout.ts

@@ -0,0 +1,202 @@
+/*
+ * Timeouts are configured per step and stored on the step config in
+ * milliseconds. Both the dashboard (which edits them) and the Worker (which
+ * enforces them) resolve values through this module so a step never runs with
+ * a bound the author could not see, and never with one that would pin a
+ * Worker slot open indefinitely.
+ */
+
+// How long the step itself may run before it is killed.
+export const DEFAULT_STEP_EXECUTION_TIMEOUT_IN_MS: number = 30 * 1000;
+export const MIN_STEP_EXECUTION_TIMEOUT_IN_MS: number = 1000;
+export const MAX_STEP_EXECUTION_TIMEOUT_IN_MS: number = 60 * 60 * 1000;
+
+/*
+ * How long the Worker waits for the selected agent to claim the job. Only
+ * meaningful for Bash and JavaScript steps, which never run on the Worker.
+ */
+export const DEFAULT_AGENT_CLAIM_TIMEOUT_IN_MS: number = 2 * 60 * 1000;
+export const MIN_AGENT_CLAIM_TIMEOUT_IN_MS: number = 1000;
+export const MAX_AGENT_CLAIM_TIMEOUT_IN_MS: number = 60 * 60 * 1000;
+
+export interface TimeoutBounds {
+  defaultInMs: number;
+  minInMs: number;
+  maxInMs: number;
+}
+
+export const STEP_EXECUTION_TIMEOUT_BOUNDS: TimeoutBounds = {
+  defaultInMs: DEFAULT_STEP_EXECUTION_TIMEOUT_IN_MS,
+  minInMs: MIN_STEP_EXECUTION_TIMEOUT_IN_MS,
+  maxInMs: MAX_STEP_EXECUTION_TIMEOUT_IN_MS,
+};
+
+export const AGENT_CLAIM_TIMEOUT_BOUNDS: TimeoutBounds = {
+  defaultInMs: DEFAULT_AGENT_CLAIM_TIMEOUT_IN_MS,
+  minInMs: MIN_AGENT_CLAIM_TIMEOUT_IN_MS,
+  maxInMs: MAX_AGENT_CLAIM_TIMEOUT_IN_MS,
+};
+
+/*
+ * Resolve a configured timeout to the value execution should actually use.
+ *
+ * Anything unusable — unset, blank, non-numeric, zero or negative — falls back
+ * to the default rather than failing the step, because a runbook that runs
+ * with the documented default is more useful during an incident than one that
+ * refuses to run at all. Usable values are rounded to whole milliseconds and
+ * clamped into range.
+ */
+export function resolveTimeoutInMs(
+  value: number | string | null | undefined,
+  bounds: TimeoutBounds,
+): number {
+  if (value === null || value === undefined || value === "") {
+    return bounds.defaultInMs;
+  }
+
+  const parsed: number = typeof value === "number" ? value : Number(value);
+
+  if (!isFinite(parsed) || parsed <= 0) {
+    return bounds.defaultInMs;
+  }
+
+  return Math.min(Math.max(Math.round(parsed), bounds.minInMs), bounds.maxInMs);
+}
+
+export function resolveStepExecutionTimeoutInMs(
+  value: number | string | null | undefined,
+): number {
+  return resolveTimeoutInMs(value, STEP_EXECUTION_TIMEOUT_BOUNDS);
+}
+
+export function resolveAgentClaimTimeoutInMs(
+  value: number | string | null | undefined,
+): number {
+  return resolveTimeoutInMs(value, AGENT_CLAIM_TIMEOUT_BOUNDS);
+}
+
+/*
+ * Milliseconds are the storage unit; seconds are what people think in. The
+ * two helpers below bridge the step editor's seconds input and the stored
+ * value. An empty input means "unset" — the step then uses the default — so
+ * it round-trips to undefined rather than to zero.
+ */
+export function timeoutInMsToSecondsInputValue(
+  value: number | null | undefined,
+): string {
+  if (value === null || value === undefined || !isFinite(Number(value))) {
+    return "";
+  }
+
+  const seconds: number = Number(value) / 1000;
+
+  if (seconds <= 0) {
+    return "";
+  }
+
+  // Sub-second values would render as "0" and read as "no timeout"; keep the decimal.
+  return String(Math.round(seconds * 1000) / 1000);
+}
+
+export function secondsInputValueToTimeoutInMs(
+  value: string,
+): number | undefined {
+  const trimmed: string = (value || "").trim();
+
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const seconds: number = Number(trimmed);
+
+  if (!isFinite(seconds) || seconds <= 0) {
+    return undefined;
+  }
+
+  const inMs: number = Math.round(seconds * 1000);
+
+  /*
+   * Sub-half-millisecond input rounds to zero. Zero is not a timeout, so it
+   * reports as unset like any other unusable value — storing a literal 0 would
+   * put a number in the step config that means nothing.
+   */
+  if (inMs <= 0) {
+    return undefined;
+  }
+
+  return inMs;
+}
+
+/*
+ * Shown when the field holds something that is not a number at all. Lives here
+ * rather than in the editor so the message the browser's own parse failure
+ * produces is the same one this validator produces.
+ */
+export const NON_NUMERIC_TIMEOUT_MESSAGE: string = "Enter a number of seconds.";
+
+/*
+ * Validation message for the step editor. Returns null when the input is
+ * acceptable — including when it is blank, which simply means "use the
+ * default". Out-of-range values are still saved and then clamped at run time;
+ * the message is what tells the author that will happen.
+ */
+export function getTimeoutValidationError(
+  value: string,
+  bounds: TimeoutBounds,
+): string | null {
+  const trimmed: string = (value || "").trim();
+
+  if (!trimmed) {
+    return null;
+  }
+
+  const seconds: number = Number(trimmed);
+
+  if (!isFinite(seconds)) {
+    return NON_NUMERIC_TIMEOUT_MESSAGE;
+  }
+
+  const inMs: number = Math.round(seconds * 1000);
+
+  /*
+   * Zero, negatives, and anything that rounds down to zero milliseconds are
+   * not timeouts. They fall back to the default rather than being clamped up,
+   * so they get the same message.
+   */
+  if (seconds <= 0 || inMs <= 0) {
+    return "Timeout must be greater than 0 seconds.";
+  }
+
+  if (inMs < bounds.minInMs) {
+    return `Minimum is ${bounds.minInMs / 1000} second${
+      bounds.minInMs === 1000 ? "" : "s"
+    }.`;
+  }
+
+  if (inMs > bounds.maxInMs) {
+    return `Maximum is ${bounds.maxInMs / 1000} seconds (${
+      bounds.maxInMs / 60000
+    } minutes).`;
+  }
+
+  return null;
+}
+
+/*
+ * True when the input is a usable number that sits outside the bounds — the
+ * only case where run time will clamp it. Unusable input (blank, zero, junk)
+ * falls back to the default instead, which is the opposite end of the range,
+ * so the editor must not promise clamping there.
+ */
+export function willTimeoutBeClamped(
+  value: string,
+  bounds: TimeoutBounds,
+): boolean {
+  const inMs: number | undefined = secondsInputValueToTimeoutInMs(value);
+
+  if (inMs === undefined) {
+    return false;
+  }
+
+  return inMs < bounds.minInMs || inMs > bounds.maxInMs;
+}

package/Types/Telemetry/DropFilterSampling.ts

@@ -0,0 +1,92 @@
+/*
+ * Sampling decision shared by the log and trace drop-filter engines.
+ *
+ * This used to be `filter.samplePercentage || 50` duplicated in two
+ * services, which had three separate problems:
+ *
+ *   1. `samplePercentage` is nullable with no default and the form field
+ *      was optional, so an UNSET percentage silently became "throw away
+ *      half of every matching record" — while the view page rendered the
+ *      same unset value as "0% kept".
+ *   2. A stored `0` was indistinguishable from unset, so it also kept 50%.
+ *   3. The two copies could drift.
+ *
+ * The fix is to fail SAFE: a percentage we cannot honour makes the filter a
+ * no-op rather than a data shredder. Callers that want "discard everything
+ * matching" have an explicit `drop` action for that.
+ *
+ * Note on the `0` case specifically. A literal reading of `0` is "keep 0%",
+ * i.e. drop every matching record — but `0` NEVER meant that in any shipped
+ * version (it kept half), so honouring it now would start deleting data
+ * that used to survive. Treating it as misconfigured is strictly less
+ * destructive than both the old behaviour and the literal reading, and
+ * save-time validation (Common/Server/Utils/DropFilterValidation.ts) stops
+ * new rows from getting there at all.
+ */
+
+// Keep everything: the fail-safe value for a percentage we can't honour.
+export const KEEP_ALL_PERCENTAGE: number = 100;
+
+/*
+ * The range a human is allowed to save. Enforced at the API boundary by
+ * Common/Server/Utils/DropFilterValidation.ts and mirrored in the dashboard
+ * form; kept here so the validator, the form and the engine cannot drift
+ * apart on what counts as a usable percentage.
+ */
+export const MIN_SAMPLE_PERCENTAGE: number = 1;
+export const MAX_SAMPLE_PERCENTAGE: number = 99;
+
+/*
+ * Whether a stored value is one the engine will actually sample on. The
+ * dashboard uses this to render "not configured" instead of the "0% kept"
+ * it used to show for an unset percentage — a display that directly
+ * contradicted the engine's old behaviour of keeping half.
+ */
+export function isSamplePercentageConfigured(
+  samplePercentage: number | undefined | null,
+): boolean {
+  return resolveSamplePercentage(samplePercentage) < KEEP_ALL_PERCENTAGE;
+}
+
+/*
+ * Normalize a stored `samplePercentage` into a percentage-to-KEEP.
+ *
+ * Anything that is not a finite number in the exclusive range (0, 100) is
+ * misconfigured and resolves to "keep everything".
+ */
+export function resolveSamplePercentage(
+  samplePercentage: number | undefined | null,
+): number {
+  if (
+    typeof samplePercentage !== "number" ||
+    !Number.isFinite(samplePercentage)
+  ) {
+    return KEEP_ALL_PERCENTAGE;
+  }
+
+  if (samplePercentage <= 0 || samplePercentage >= KEEP_ALL_PERCENTAGE) {
+    return KEEP_ALL_PERCENTAGE;
+  }
+
+  return samplePercentage;
+}
+
+/*
+ * True when a sample-action filter should discard this record.
+ *
+ * `random` is injectable so the decision is testable without stubbing
+ * global Math.random. It is only consulted when the percentage actually
+ * calls for sampling, so a keep-everything filter costs no entropy.
+ */
+export function shouldDropBySampling(
+  samplePercentage: number | undefined | null,
+  random: () => number = Math.random,
+): boolean {
+  const keepPercentage: number = resolveSamplePercentage(samplePercentage);
+
+  if (keepPercentage >= KEEP_ALL_PERCENTAGE) {
+    return false;
+  }
+
+  return random() * 100 >= keepPercentage;
+}

package/UI/Components/AI/GenerateFromAIModal.tsx

@@ -9,7 +9,6 @@ import AILoader from "./AILoader";
 import Alert, { AlertType } from "../Alerts/Alert";
 import ButtonType from "../Button/ButtonTypes";
 import { ButtonStyleType } from "../Button/Button";
-import IconProp from "../../../Types/Icon/IconProp";
 import Dropdown, { DropdownOption, DropdownValue } from "../Dropdown/Dropdown";
 import MarkdownEditor from "../Markdown.tsx/MarkdownEditor";
 
@@ -112,7 +111,6 @@ const GenerateFromAIModal: FunctionComponent<GenerateFromAIModalProps> = (
       disableSubmitButton={isGenerating}
       onSubmit={handleGenerate}
       modalWidth={ModalWidth.Large}
-      icon={IconProp.Bolt}
     >
       <>
         {error && (

package/UI/Components/Accordion/Accordion.tsx

@@ -32,13 +32,21 @@ const Accordion: FunctionComponent<ComponentProps> = (
     }
   }, [props.isInitiallyExpanded]);
 
+  /*
+   * A title-less accordion has nothing to click, so it stays open. Keyed on
+   * whether there is a title rather than on the title itself: callers may pass
+   * an element, and a fresh element on every parent render would otherwise
+   * collapse an accordion the visitor had just opened.
+   */
+  const hasTitle: boolean = Boolean(props.title);
+
   useEffect(() => {
-    if (!props.title) {
+    if (!hasTitle) {
       setIsOpen(true);
     } else if (!props.isInitiallyExpanded) {
       setIsOpen(false);
     }
-  }, [props.title]);
+  }, [hasTitle]);
 
   useEffect(() => {
     if (props.onClick) {

package/UI/Components/BulkUpdate/BulkLabelActions.tsx

@@ -370,7 +370,6 @@ function useBulkLabelActions<T extends BaseModel>(
           <Modal
             title="No Labels to Remove"
             description="The selected items don't have any labels to remove."
-            icon={IconProp.Label}
             onClose={closeRemoveModal}
             closeButtonText="Close"
           >

package/UI/Components/CodeEditor/CodeEditor.tsx

@@ -32,6 +32,22 @@ export interface ComponentProps {
   ariaLabelledby?: string | undefined;
 }
 
+/*
+ * Callers hand us `any` through Form's currentValues, so a non-string can
+ * still reach a prop typed as string.
+ */
+function toEditorText(value: string | undefined): string {
+  if (value === undefined || value === null) {
+    return "";
+  }
+
+  if (typeof value !== "string") {
+    return JSON.stringify(value, null, 4);
+  }
+
+  return value;
+}
+
 const CodeEditor: FunctionComponent<ComponentProps> = (
   props: ComponentProps,
 ): ReactElement => {
@@ -42,15 +58,25 @@ const CodeEditor: FunctionComponent<ComponentProps> = (
   const editorRef: React.MutableRefObject<any> = useRef<any>(null);
   const theme: Theme = useTheme();
 
-  useEffect(() => {
-    let value: string | undefined = props.value;
-
-    if (value && typeof value !== "string") {
-      value = JSON.stringify(value, null, 4);
-    }
+  /*
+   * `value` is the controlled prop; `initialValue` only seeds an uncontrolled
+   * editor. Both used to be synced from their own useEffect, and because
+   * effects run in declaration order the `initialValue` one ran last on mount
+   * and reset the state to "" - so a caller that passed only `value` mounted
+   * an empty editor even though it had text to show. Seed the state on the
+   * first render and keep the precedence in a single effect.
+   */
+  const [value, setValue] = useState<string>(() => {
+    return toEditorText(props.value ?? props.initialValue);
+  });
 
-    setValue(value || "");
-  }, [props.value]);
+  useEffect(() => {
+    setValue(
+      toEditorText(
+        props.value === undefined ? props.initialValue : props.value,
+      ),
+    );
+  }, [props.value, props.initialValue]);
 
   useEffect(() => {
     if (props.placeholder) {
@@ -95,8 +121,6 @@ const CodeEditor: FunctionComponent<ComponentProps> = (
       "block w-full rounded-md border bg-white py-2 pl-3 pr-3 text-sm placeholder-gray-500 focus:border-red-500 focus:text-gray-900 focus:placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-red-500 sm:text-sm border-red-300 pr-10 text-red-900 placeholder-red-300 focus:border-red-500 focus:outline-none focus:ring-red-500";
   }
 
-  const [value, setValue] = useState<string>("");
-
   // Handle spell check configuration for Monaco Editor
   useEffect(() => {
     if (editorRef.current && props.type === CodeType.Markdown) {
@@ -112,16 +136,6 @@ const CodeEditor: FunctionComponent<ComponentProps> = (
     }
   }, [props.disableSpellCheck, props.type]);
 
-  useEffect(() => {
-    let initialValue: string | undefined = props.initialValue;
-
-    if (initialValue && typeof initialValue !== "string") {
-      initialValue = JSON.stringify(initialValue, null, 4);
-    }
-
-    setValue(initialValue || "");
-  }, [props.initialValue]);
-
   return (
     <div
       data-testid={props.dataTestId}

package/UI/Components/Date/RangeStartAndEndDateView.tsx

@@ -103,7 +103,6 @@ const DashboardStartAndEndDateView: FunctionComponent<ComponentProps> = (
           <Modal
             title="Select Time Range"
             description="Choose a quick range or set an exact start and end date & time."
-            icon={IconProp.Clock}
             modalWidth={ModalWidth.Medium}
             submitButtonText="Apply"
             disableSubmitButton={!isSelectionValid(tempStartAndEndDate)}

package/UI/Components/EditionLabel/EditionLabel.tsx

@@ -1,5 +1,5 @@
 import Modal, { ModalWidth } from "../Modal/Modal";
-import Icon, { IconType } from "../Icon/Icon";
+import Icon from "../Icon/Icon";
 import IconProp from "../../../Types/Icon/IconProp";
 import Input from "../Input/Input";
 import Button, { ButtonStyleType } from "../Button/Button";
@@ -759,30 +759,6 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
     globalConfig?.enterpriseLicenseKey,
   ]);
 
-  const modalIcon: IconProp = useMemo(() => {
-    if (!IS_ENTERPRISE_EDITION || isConfigLoading) {
-      return IconProp.Cube;
-    }
-
-    if (!licenseValid || isUserLimitBreached) {
-      return IconProp.Alert;
-    }
-
-    return IconProp.ShieldCheck;
-  }, [isConfigLoading, licenseValid, isUserLimitBreached]);
-
-  const modalIconType: IconType = useMemo(() => {
-    if (!IS_ENTERPRISE_EDITION || isConfigLoading) {
-      return IconType.Info;
-    }
-
-    if (!licenseValid || isUserLimitBreached) {
-      return IconType.Danger;
-    }
-
-    return IconType.Success;
-  }, [isConfigLoading, licenseValid, isUserLimitBreached]);
-
   const modalDescription: string = useMemo(() => {
     if (!IS_ENTERPRISE_EDITION) {
       return "You are running the free, open-source build of OneUptime.";
@@ -1326,8 +1302,6 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
         <Modal
           title={editionName}
           description={modalDescription}
-          icon={modalIcon}
-          iconType={modalIconType}
           rightElement={modalRightElement}
           submitButtonText={modalSubmitButtonText}
           closeButtonText="Close"