ydb-embedded-ui 5.4.0 → 6.0.0

package/dist/store/reducers/tenants/selectors.js

@@ -1,7 +1,8 @@
 import { createSelector } from '@reduxjs/toolkit';
-import { escapeRegExp } from 'lodash';
+import escapeRegExp from 'lodash/escapeRegExp';
 import { EFlag } from '../../../types/api/enums';
 import { ProblemFilterValues, selectProblemFilter } from '../settings/settings';
+import { tenantsApi } from './tenants';
 // ==== Filters ====
 const filterTenantsByProblems = (tenants, problemFilter) => {
     if (problemFilter === ProblemFilterValues.ALL) {
@@ -18,7 +19,8 @@ const filteredTenantsBySearch = (tenants, searchQuery) => {
     });
 };
 // ==== Simple selectors ====
-export const selectTenants = (state) => state.tenants.tenants;
+const createGetTenantsInfoSelector = createSelector((clusterName) => clusterName, (clusterName) => tenantsApi.endpoints.getTenantsInfo.select({ clusterName }));
+export const selectTenants = createSelector((state) => state, (_state, clusterName) => createGetTenantsInfoSelector(clusterName), (state, selectTenantsInfo) => { var _a; return (_a = selectTenantsInfo(state).data) !== null && _a !== void 0 ? _a : []; });
 export const selectTenantsSearchValue = (state) => state.tenants.searchValue;
 // ==== Complex selectors ====
 export const selectFilteredTenants = createSelector([selectTenants, selectProblemFilter, selectTenantsSearchValue], (tenants, problemFilter, searchQuery) => {

package/dist/store/reducers/tenants/tenants.d.ts

@@ -1,133 +1,9 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { TenantsAction, TenantsState } from './types';
-export declare const FETCH_TENANTS: {
-    readonly REQUEST: "tenants/FETCH_TENANTS_REQUEST";
-    readonly SUCCESS: "tenants/FETCH_TENANTS_SUCCESS";
-    readonly FAILURE: "tenants/FETCH_TENANTS_FAILURE";
-};
-declare const tenants: Reducer<TenantsState, TenantsAction>;
-export declare function getTenantsInfo(clusterName?: string): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
-    singleClusterMode: boolean;
-    nodes: import("../nodes/types").NodesState;
-    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
-    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
-    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
-    cluster: import("../cluster/types").ClusterState;
-    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
-    tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
-    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
-    node: import("../node/types").NodeState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").ITabletsState;
-    schema: import("../schema/types").SchemaState;
-    overview: import("../overview/types").OverviewState;
-    olapStats: import("../../../types/store/olapStats").OlapStatsState;
-    host: import("../../../types/store/host").IHostState;
-    network: import("../network/types").NetworkState;
-    tenants: TenantsState;
-    tablet: import("../../../types/store/tablet").ITabletState;
-    topic: import("../../../types/store/topic").ITopicState;
-    partitions: import("../partitions/types").PartitionsState;
-    pDisk: import("../pdisk/types").PDiskState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
-    tabletsFilters: {
-        loading: boolean;
-        requestTime: number;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        tabletsData: any;
-        nodes: any;
-        loading: boolean;
-        wasLoaded: boolean;
-        timeoutForRequest: number;
-        error: undefined;
-        data: undefined;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        error: any;
-        loading: boolean;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        stateFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        typeFilter: never[];
-    } | {
-        typeFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-    };
-    heatmap: import("../../../types/store/heatmap").IHeatmapState;
-    settings: import("../settings/types").SettingsState;
-    preview: any;
-    nodesList: import("../../../types/store/nodesList").NodesListState;
-    describe: import("../../../types/store/describe").IDescribeState;
-    schemaAcl: import("../schemaAcl/types").SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
-    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
-    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
-    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
-    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
-    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
-    hotKeys: import("../hotKeys/types").HotKeysState;
-    authentication: import("../authentication/types").AuthenticationState;
-    header: import("../header/types").HeaderState;
-    saveQuery: string | null;
-    fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersState;
-}) => Promise<{
-    backend: string | undefined;
-    sharedTenantName: string | undefined;
-    controlPlaneName: string;
-    cpu: number | undefined;
-    memory: number | undefined;
-    storage: number | undefined;
-    nodesCount: number;
-    groupsCount: number;
-    Name?: string | undefined;
-    Id?: string | undefined;
-    Type?: import("../../../types/api/tenant").ETenantType | undefined;
-    State?: import("../../../types/api/tenant").State | undefined;
-    StateStats?: import("../../../types/api/tenant").THiveDomainStatsStateCount[] | undefined;
-    Metrics?: import("../../../types/api/tenant").TMetrics | undefined;
-    NodeIds?: number[] | undefined;
-    AliveNodes?: number | undefined;
-    Resources?: import("../../../types/api/tenant").TTenantResources | undefined;
-    CreateTime?: string | undefined;
-    Owner?: string | undefined;
-    Users?: string[] | undefined;
-    PoolStats?: import("../../../types/api/nodes").TPoolStats[] | undefined;
-    UserAttributes?: Record<string, string> | undefined;
-    Overall?: import("../../../types/api/enums").EFlag | undefined;
-    SystemTablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
-    ResourceId?: string | undefined;
-    Tablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
-    StorageAllocatedSize?: string | undefined;
-    StorageMinAvailableSize?: string | undefined;
-    Nodes?: import("../../../types/api/nodes").TSystemStateInfo[] | undefined;
-    MemoryUsed?: string | undefined;
-    MemoryLimit?: string | undefined;
-    CoresUsed?: number | undefined;
-    StorageGroups?: string | undefined;
-    MonitoringEndpoint?: string | undefined;
-    ControlPlane?: import("../../../types/api/tenant").ControlPlane | undefined;
-    StorageAllocatedLimit?: string | undefined;
-    DatabaseQuotas?: import("../../../types/api/tenant").DatabaseQuotas | undefined;
-}[] | undefined>;
-export declare const setSearchValue: (value: string) => {
-    readonly type: "tenants/SET_SEARCH_VALUE";
-    readonly data: string;
-};
-export default tenants;
+import type { PreparedTenant, TenantsState } from './types';
+export declare const setSearchValue: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "tenants/setSearchValue">;
+declare const _default: import("redux").Reducer<TenantsState>;
+export default _default;
+export declare const tenantsApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getTenantsInfo: import("@reduxjs/toolkit/query").QueryDefinition<{
+        clusterName?: string | undefined;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", PreparedTenant[] | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/store/reducers/tenants/tenants.js

@@ -1,43 +1,40 @@
-import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { createSlice } from '@reduxjs/toolkit';
+import { api } from '../api';
 import { prepareTenants } from './utils';
-export const FETCH_TENANTS = createRequestActionTypes('tenants', 'FETCH_TENANTS');
-const SET_SEARCH_VALUE = 'tenants/SET_SEARCH_VALUE';
-const initialState = { loading: true, wasLoaded: false, searchValue: '', tenants: [] };
-const tenants = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_TENANTS.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_TENANTS.SUCCESS: {
-            return Object.assign(Object.assign({}, state), { tenants: action.data, loading: false, wasLoaded: true, error: undefined });
-        }
-        case FETCH_TENANTS.FAILURE: {
-            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
-        }
-        case SET_SEARCH_VALUE: {
-            return Object.assign(Object.assign({}, state), { searchValue: action.data });
-        }
-        default:
-            return state;
-    }
-};
-export function getTenantsInfo(clusterName) {
-    return createApiRequest({
-        request: window.api.getTenants(clusterName),
-        actions: FETCH_TENANTS,
-        dataHandler: (response, getState) => {
-            const { singleClusterMode } = getState();
-            if (!response.TenantInfo) {
-                return [];
-            }
-            return prepareTenants(response.TenantInfo, singleClusterMode);
+const initialState = { searchValue: '' };
+const slice = createSlice({
+    name: 'tenants',
+    initialState,
+    reducers: {
+        setSearchValue: (state, action) => {
+            state.searchValue = action.payload;
         },
-    });
-}
-export const setSearchValue = (value) => {
-    return {
-        type: SET_SEARCH_VALUE,
-        data: value,
-    };
-};
-export default tenants;
+    },
+});
+export const { setSearchValue } = slice.actions;
+export default slice.reducer;
+export const tenantsApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        getTenantsInfo: build.query({
+            queryFn: async ({ clusterName }, { signal, getState }) => {
+                try {
+                    const response = await window.api.getTenants(clusterName, { signal });
+                    let data;
+                    if (Array.isArray(response.TenantInfo)) {
+                        const { singleClusterMode } = getState();
+                        data = prepareTenants(response.TenantInfo, singleClusterMode);
+                    }
+                    else {
+                        data = [];
+                    }
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

package/dist/store/reducers/tenants/types.d.ts

@@ -1,27 +1,19 @@
-import { FETCH_TENANTS, setSearchValue } from './tenants';
-import { ValueOf } from '../../../types/common';
 import type { TTenant } from '../../../types/api/tenant';
-import type { IResponseError } from '../../../types/api/error';
-import type { ApiRequestAction } from '../../utils';
-import { METRIC_STATUS } from './contants';
+import type { ValueOf } from '../../../types/common';
+import type { METRIC_STATUS } from './contants';
 export interface PreparedTenant extends TTenant {
     backend: string | undefined;
     sharedTenantName: string | undefined;
     controlPlaneName: string;
-    cpu: number;
-    memory: number;
-    storage: number;
+    cpu: number | undefined;
+    memory: number | undefined;
+    storage: number | undefined;
     nodesCount: number;
     groupsCount: number;
 }
 export interface TenantsState {
-    loading: boolean;
-    wasLoaded: boolean;
     searchValue: string;
-    tenants: PreparedTenant[];
-    error?: IResponseError;
 }
-export type TenantsAction = ApiRequestAction<typeof FETCH_TENANTS, PreparedTenant[], IResponseError> | ReturnType<typeof setSearchValue>;
 export interface TenantsStateSlice {
     tenants: TenantsState;
 }

package/dist/store/reducers/tenants/utils.d.ts

@@ -1,56 +1,37 @@
-import type { TPoolStats } from '../../../types/api/nodes';
+import type { PoolName } from '../../../types/api/nodes';
 import type { TTenant } from '../../../types/api/tenant';
+import { EType } from '../../../types/api/tenant';
+import type { PreparedTenant } from './types';
+export interface TenantMetricStats<T = string> {
+    name: T;
+    usage?: number;
+    limit?: number;
+    used?: number;
+}
+export type TenantPoolsStats = TenantMetricStats<PoolName>;
+export type TenantStorageStats = TenantMetricStats<EType>;
 export declare const calculateTenantMetrics: (tenant?: TTenant) => {
-    cpu: number | undefined;
     memory: number | undefined;
     blobStorage: number | undefined;
     tabletStorage: number | undefined;
-    cpuUsage: number | undefined;
     memoryLimit: number | undefined;
     blobStorageLimit: number | undefined;
     tabletStorageLimit: number | undefined;
-};
-export declare const prepareTenants: (tenants: TTenant[], useNodeAsBackend: boolean) => {
-    backend: string | undefined;
-    sharedTenantName: string | undefined;
-    controlPlaneName: string;
     cpu: number | undefined;
-    memory: number | undefined;
-    storage: number | undefined;
-    nodesCount: number;
-    groupsCount: number;
-    Name?: string | undefined;
-    Id?: string | undefined;
-    Type?: import("../../../types/api/tenant").ETenantType | undefined;
-    State?: import("../../../types/api/tenant").State | undefined;
-    StateStats?: import("../../../types/api/tenant").THiveDomainStatsStateCount[] | undefined;
-    Metrics?: import("../../../types/api/tenant").TMetrics | undefined;
-    NodeIds?: number[] | undefined;
-    AliveNodes?: number | undefined;
-    Resources?: import("../../../types/api/tenant").TTenantResources | undefined;
-    CreateTime?: string | undefined;
-    Owner?: string | undefined;
-    Users?: string[] | undefined;
-    PoolStats?: TPoolStats[] | undefined;
-    UserAttributes?: Record<string, string> | undefined;
-    Overall?: import("../../../types/api/enums").EFlag | undefined;
-    SystemTablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
-    ResourceId?: string | undefined;
-    Tablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
-    StorageAllocatedSize?: string | undefined;
-    StorageMinAvailableSize?: string | undefined;
-    Nodes?: import("../../../types/api/nodes").TSystemStateInfo[] | undefined;
-    MemoryUsed?: string | undefined;
-    MemoryLimit?: string | undefined;
-    CoresUsed?: number | undefined;
-    StorageGroups?: string | undefined;
-    MonitoringEndpoint?: string | undefined;
-    ControlPlane?: import("../../../types/api/tenant").ControlPlane | undefined;
-    StorageAllocatedLimit?: string | undefined;
-    DatabaseQuotas?: import("../../../types/api/tenant").DatabaseQuotas | undefined;
-}[];
-export declare const calculateUsage: (valueUsed?: number, valueLimit?: number) => number | undefined;
+    poolsStats: TenantPoolsStats[] | undefined;
+    memoryStats: TenantMetricStats<string>[];
+    blobStorageStats: TenantStorageStats[];
+    tabletStorageStats: TenantStorageStats[] | undefined;
+};
+export declare const prepareTenants: (tenants: TTenant[], useNodeAsBackend: boolean) => PreparedTenant[];
+export declare function calculateUsage(valueUsed?: number, valueLimit?: number): number | undefined;
 export declare const formatUsage: (usage?: number) => string | undefined;
+export declare const TENANT_CPU_DANGER_TRESHOLD = 70;
+export declare const TENANT_CPU_WARNING_TRESHOLD = 60;
+export declare const TENANT_STORAGE_DANGER_TRESHOLD = 85;
+export declare const TENANT_STORAGE_WARNING_TRESHOLD = 75;
+export declare const TENANT_MEMORY_DANGER_TRESHOLD = 70;
+export declare const TENANT_MEMORY_WARNING_TRESHOLD = 60;
 export declare const cpuUsageToStatus: (usage?: number) => "Unspecified" | "Good" | "Warning" | "Danger";
 export declare const storageUsageToStatus: (usage?: number) => "Unspecified" | "Good" | "Warning" | "Danger";
 export declare const memoryUsageToStatus: (usage?: number) => "Unspecified" | "Good" | "Warning" | "Danger";

package/dist/store/reducers/tenants/utils.js

@@ -1,3 +1,4 @@
+import { EType } from '../../../types/api/tenant';
 import { formatBytes } from '../../../utils/bytesParsers';
 import { formatCPUWithLabel } from '../../../utils/dataFormatters/dataFormatters';
 import { isNumeric } from '../../../utils/utils';
@@ -17,25 +18,29 @@ const getTenantBackend = (tenant) => {
         : undefined;
     return node.Host ? `${node.Host}${address ? address : ''}` : undefined;
 };
-const calculateCpuUsage = (poolsStats) => {
-    var _a, _b, _c;
+const calculatePoolsStats = (poolsStats) => {
     if (!poolsStats) {
         return undefined;
     }
-    const systemPoolUsage = ((_a = poolsStats === null || poolsStats === void 0 ? void 0 : poolsStats.find(({ Name }) => Name === 'System')) === null || _a === void 0 ? void 0 : _a.Usage) || 0;
-    const userPoolUsage = ((_b = poolsStats === null || poolsStats === void 0 ? void 0 : poolsStats.find(({ Name }) => Name === 'User')) === null || _b === void 0 ? void 0 : _b.Usage) || 0;
-    const icPoolUsage = ((_c = poolsStats === null || poolsStats === void 0 ? void 0 : poolsStats.find(({ Name }) => Name === 'IC')) === null || _c === void 0 ? void 0 : _c.Usage) || 0;
-    // We use max of system, user and ic pools usage to calculate cpu usage because
-    // only these pools directly indicate resources available to perform user queries
-    return Math.max(Number(systemPoolUsage), Number(userPoolUsage), Number(icPoolUsage)) * 100;
+    return poolsStats
+        .map((pool) => {
+        if (pool.Name) {
+            const usage = Number(pool.Usage);
+            const limit = Number(pool.Threads);
+            const used = limit * usage;
+            // Multiply usage by 100 to match with usage to status checkers
+            return { name: pool.Name, usage: usage * 100, limit, used };
+        }
+        return undefined;
+    })
+        .filter((stats) => stats !== undefined);
 };
-export const calculateTenantMetrics = (tenant) => {
-    const { CoresUsed, MemoryUsed, StorageAllocatedSize, MemoryLimit, StorageAllocatedLimit, PoolStats, Metrics = {}, DatabaseQuotas = {}, } = tenant || {};
+export const calculateTenantMetrics = (tenant = {}) => {
+    const { CoresUsed, MemoryUsed, StorageAllocatedSize, MemoryLimit, StorageAllocatedLimit, PoolStats, Metrics = {}, DatabaseQuotas = {}, StorageUsage, QuotaUsage, } = tenant;
     const cpu = isNumeric(CoresUsed) ? Number(CoresUsed) * 1000000 : undefined;
     const memory = isNumeric(MemoryUsed) ? Number(MemoryUsed) : undefined;
     const blobStorage = isNumeric(StorageAllocatedSize) ? Number(StorageAllocatedSize) : undefined;
     const tabletStorage = isNumeric(Metrics.Storage) ? Number(Metrics.Storage) : undefined;
-    const cpuUsage = calculateCpuUsage(PoolStats);
     const memoryLimit = isNumeric(MemoryLimit) ? Number(MemoryLimit) : undefined;
     const blobStorageLimit = isNumeric(StorageAllocatedLimit)
         ? Number(StorageAllocatedLimit)
@@ -43,15 +48,75 @@ export const calculateTenantMetrics = (tenant) => {
     const tabletStorageLimit = isNumeric(DatabaseQuotas.data_size_hard_quota)
         ? Number(DatabaseQuotas.data_size_hard_quota)
         : undefined;
+    const poolsStats = calculatePoolsStats(PoolStats);
+    let blobStorageStats;
+    let tabletStorageStats;
+    if (StorageUsage) {
+        blobStorageStats = StorageUsage.map((value) => {
+            const { Type, Size, Limit } = value;
+            const used = Number(Size);
+            const limit = Number(Limit);
+            return {
+                name: Type,
+                used,
+                limit,
+                usage: calculateUsage(used, limit),
+            };
+        });
+    }
+    else {
+        blobStorageStats = [
+            {
+                name: EType.SSD,
+                used: blobStorage,
+                limit: blobStorageLimit,
+                usage: calculateUsage(blobStorage, blobStorageLimit),
+            },
+        ];
+    }
+    if (QuotaUsage) {
+        tabletStorageStats = QuotaUsage.map((value) => {
+            const { Type, Size, Limit } = value;
+            const used = Number(Size);
+            const limit = Number(Limit);
+            return {
+                name: Type,
+                used,
+                limit,
+                usage: calculateUsage(used, limit),
+            };
+        });
+    }
+    else if (tabletStorage !== undefined && tabletStorageLimit) {
+        tabletStorageStats = [
+            {
+                name: EType.SSD,
+                used: tabletStorage,
+                limit: tabletStorageLimit,
+                usage: calculateUsage(tabletStorage, tabletStorageLimit),
+            },
+        ];
+    }
+    const memoryStats = [
+        {
+            name: 'Process',
+            used: memory,
+            limit: memoryLimit,
+            usage: calculateUsage(memory, memoryLimit),
+        },
+    ];
     return {
-        cpu,
         memory,
         blobStorage,
         tabletStorage,
-        cpuUsage,
         memoryLimit,
         blobStorageLimit,
         tabletStorageLimit,
+        cpu,
+        poolsStats,
+        memoryStats,
+        blobStorageStats,
+        tabletStorageStats,
     };
 };
 const calculateTenantEntities = (tenant) => {
@@ -77,26 +142,32 @@ export const prepareTenants = (tenants, useNodeAsBackend) => {
             groupsCount });
     });
 };
-export const calculateUsage = (valueUsed, valueLimit) => {
+export function calculateUsage(valueUsed, valueLimit) {
     if (valueUsed && valueLimit) {
         return (valueUsed * 100) / valueLimit;
     }
     return undefined;
-};
+}
 export const formatUsage = (usage) => {
     if (usage) {
         return `${usage.toFixed()}%`;
     }
     return undefined;
 };
+export const TENANT_CPU_DANGER_TRESHOLD = 70;
+export const TENANT_CPU_WARNING_TRESHOLD = 60;
+export const TENANT_STORAGE_DANGER_TRESHOLD = 85;
+export const TENANT_STORAGE_WARNING_TRESHOLD = 75;
+export const TENANT_MEMORY_DANGER_TRESHOLD = 70;
+export const TENANT_MEMORY_WARNING_TRESHOLD = 60;
 export const cpuUsageToStatus = (usage) => {
     if (!usage) {
         return METRIC_STATUS.Unspecified;
     }
-    if (usage > 70) {
+    if (usage > TENANT_CPU_DANGER_TRESHOLD) {
         return METRIC_STATUS.Danger;
     }
-    if (usage > 60) {
+    if (usage > TENANT_CPU_WARNING_TRESHOLD) {
         return METRIC_STATUS.Warning;
     }
     return METRIC_STATUS.Good;
@@ -105,10 +176,10 @@ export const storageUsageToStatus = (usage) => {
     if (!usage) {
         return METRIC_STATUS.Unspecified;
     }
-    if (usage > 85) {
+    if (usage > TENANT_STORAGE_DANGER_TRESHOLD) {
         return METRIC_STATUS.Danger;
     }
-    if (usage > 75) {
+    if (usage > TENANT_STORAGE_WARNING_TRESHOLD) {
         return METRIC_STATUS.Warning;
     }
     return METRIC_STATUS.Good;
@@ -117,10 +188,10 @@ export const memoryUsageToStatus = (usage) => {
     if (!usage) {
         return METRIC_STATUS.Unspecified;
     }
-    if (usage > 70) {
+    if (usage > TENANT_MEMORY_DANGER_TRESHOLD) {
         return METRIC_STATUS.Danger;
     }
-    if (usage > 60) {
+    if (usage > TENANT_MEMORY_WARNING_TRESHOLD) {
         return METRIC_STATUS.Warning;
     }
     return METRIC_STATUS.Good;

package/dist/store/reducers/tooltip.d.ts

@@ -1,5 +1,5 @@
 import type { Reducer } from '@reduxjs/toolkit';
-import { ITooltipAction, ITooltipPositions, ITooltipState, ITooltipTemplateType } from '../../types/store/tooltip';
+import type { ITooltipAction, ITooltipPositions, ITooltipState, ITooltipTemplateType } from '../../types/store/tooltip';
 export declare const UPDATE_REF = "tooltip/UPDATE_REF";
 declare const tooltip: Reducer<ITooltipState, ITooltipAction>;
 export declare const hideTooltip: () => {
@@ -9,7 +9,7 @@ export declare const showTooltip: (node: EventTarget | null, data: any, template
     type: string;
     node: EventTarget | null;
     data: any;
-    templateType: "node" | "pool" | "tablet" | "nodeEndpoints" | "tabletsOverall" | "histogram" | "cell" | "json";
+    templateType: "pool" | "tablet" | "node" | "nodeEndpoints" | "tabletsOverall" | "histogram" | "cell" | "json";
     additionalData: any;
     positions: ITooltipPositions | undefined;
 };