ydb-embedded-ui 3.1.0 → 3.2.0

package/dist/store/reducers/describe.ts

@@ -2,7 +2,6 @@ import {createSelector, Selector} from 'reselect';
 import {Reducer} from 'redux';
 
 import '../../services/api';
-import {IConsumer} from '../../types/api/consumers';
 import {
     IDescribeRootStateSlice,
     IDescribeState,
@@ -100,6 +99,10 @@ const selectConsumersNames = (state: IDescribeRootStateSlice, path?: string) =>
         ? state.describe.data[path]?.PathDescription?.PersQueueGroup?.PQTabletConfig?.ReadRules
         : undefined;
 
+interface IConsumer {
+    name: string;
+}
+
 export const selectConsumers: Selector<IDescribeRootStateSlice, IConsumer[], [string | undefined]> =
     createSelector(selectConsumersNames, (names = []) => names.map((name) => ({name})));
 

package/dist/store/reducers/executeTopQueries.ts

@@ -0,0 +1,170 @@
+import type {AnyAction, Reducer} from 'redux';
+import type {ThunkAction} from 'redux-thunk';
+
+import '../../services/api';
+import {
+    ITopQueriesAction,
+    ITopQueriesFilters,
+    ITopQueriesState,
+} from '../../types/store/executeTopQueries';
+import {IQueryResult} from '../../types/store/query';
+
+import {parseQueryAPIExecuteResponse} from '../../utils/query';
+
+import {createRequestActionTypes, createApiRequest} from '../utils';
+
+import type {IRootState} from '.';
+
+export const FETCH_TOP_QUERIES = createRequestActionTypes('top-queries', 'FETCH_TOP_QUERIES');
+const SET_TOP_QUERIES_STATE = 'top-queries/SET_TOP_QUERIES_STATE';
+const SET_TOP_QUERIES_FILTERS = 'top-queries/SET_TOP_QUERIES_FILTERS';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    filters: {},
+};
+
+const getMaxIntervalSubquery = (path: string) => `(
+    SELECT
+        MAX(IntervalEnd)
+    FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+)`;
+
+function getFiltersConditions(path: string, filters?: ITopQueriesFilters) {
+    const conditions: string[] = [];
+
+    if (filters?.from && filters?.to && filters.from > filters.to) {
+        throw new Error('Invalid date range');
+    }
+
+    if (filters?.from) {
+        // matching `from` & `to` is an edge case
+        // other cases should not include the starting point, since intervals are stored using the ending time
+        const gt = filters.to === filters.from ? '>=' : '>';
+        conditions.push(`IntervalEnd ${gt} Timestamp('${new Date(filters.from).toISOString()}')`);
+    }
+
+    if (filters?.to) {
+        conditions.push(`IntervalEnd <= Timestamp('${new Date(filters.to).toISOString()}')`);
+    }
+
+    if (!filters?.from && !filters?.to) {
+        conditions.push(`IntervalEnd IN ${getMaxIntervalSubquery(path)}`);
+    }
+
+    if (filters?.text) {
+        conditions.push(`QueryText ILIKE '%${filters.text}%'`);
+    }
+
+    return conditions.join(' AND ');
+}
+
+const getQueryText = (path: string, filters?: ITopQueriesFilters) => {
+    const filterConditions = getFiltersConditions(path, filters);
+    return `
+SELECT
+    CPUTime as CPUTimeUs,
+    QueryText,
+    IntervalEnd
+FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+WHERE ${filterConditions || 'true'}
+`;
+};
+
+const executeTopQueries: Reducer<ITopQueriesState, ITopQueriesAction> = (
+    state = initialState,
+    action,
+) => {
+    switch (action.type) {
+        case FETCH_TOP_QUERIES.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TOP_QUERIES.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TOP_QUERIES.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_TOP_QUERIES_STATE:
+            return {
+                ...state,
+                ...action.data,
+            };
+        case SET_TOP_QUERIES_FILTERS:
+            return {
+                ...state,
+                filters: {
+                    ...state.filters,
+                    ...action.filters,
+                },
+            };
+        default:
+            return state;
+    }
+};
+
+type FetchTopQueries = (params: {
+    database: string;
+    filters?: ITopQueriesFilters;
+}) => ThunkAction<Promise<IQueryResult | undefined>, IRootState, unknown, AnyAction>;
+
+export const fetchTopQueries: FetchTopQueries =
+    ({database, filters}) =>
+    async (dispatch, getState) => {
+        try {
+            return createApiRequest({
+                request: window.api.sendQuery(
+                    {
+                        schema: 'modern',
+                        query: getQueryText(database, filters),
+                        database,
+                        action: 'execute-scan',
+                    },
+                    {
+                        concurrentId: 'executeTopQueries',
+                    },
+                ),
+                actions: FETCH_TOP_QUERIES,
+                dataHandler: parseQueryAPIExecuteResponse,
+            })(dispatch, getState);
+        } catch (error) {
+            dispatch({
+                type: FETCH_TOP_QUERIES.FAILURE,
+                error,
+            });
+
+            throw error;
+        }
+    };
+
+export function setTopQueriesState(state: Partial<ITopQueriesState>) {
+    return {
+        type: SET_TOP_QUERIES_STATE,
+        data: state,
+    } as const;
+}
+
+export function setTopQueriesFilters(filters: Partial<ITopQueriesFilters>) {
+    return {
+        type: SET_TOP_QUERIES_FILTERS,
+        filters,
+    } as const;
+}
+
+export default executeTopQueries;

package/dist/store/reducers/settings.js

@@ -30,7 +30,7 @@ export const initialState = {
         ...defaultUserSettings,
         ...userSettings,
         [THEME_KEY]: readSavedSettingsValue(THEME_KEY, 'light'),
-        [INVERTED_DISKS_KEY]: readSavedSettingsValue(INVERTED_DISKS_KEY) === 'true',
+        [INVERTED_DISKS_KEY]: readSavedSettingsValue(INVERTED_DISKS_KEY, 'false'),
         [SAVED_QUERIES_KEY]: readSavedSettingsValue(SAVED_QUERIES_KEY, '[]'),
         [TENANT_INITIAL_TAB_KEY]: readSavedSettingsValue(TENANT_INITIAL_TAB_KEY),
         [QUERY_INITIAL_RUN_ACTION_KEY]: readSavedSettingsValue(QUERY_INITIAL_RUN_ACTION_KEY),

package/dist/store/reducers/shardsWorkload.ts

@@ -12,8 +12,8 @@ import {parseQueryAPIExecuteResponse} from '../../utils/query';
 import {createRequestActionTypes, createApiRequest} from '../utils';
 
 export const SEND_SHARD_QUERY = createRequestActionTypes('query', 'SEND_SHARD_QUERY');
-const SET_SHARD_QUERY_OPTIONS = 'query/SET_SHARD_QUERY_OPTIONS';
-const SET_TOP_SHARDS_FILTERS = 'shardsWorkload/SET_TOP_SHARDS_FILTERS';
+const SET_SHARD_STATE = 'query/SET_SHARD_STATE';
+const SET_SHARD_QUERY_FILTERS = 'shardsWorkload/SET_SHARD_QUERY_FILTERS';
 
 const initialState = {
     loading: false,
@@ -115,12 +115,12 @@ const shardsWorkload: Reducer<IShardsWorkloadState, IShardsWorkloadAction> = (
                 loading: false,
             };
         }
-        case SET_SHARD_QUERY_OPTIONS:
+        case SET_SHARD_STATE:
             return {
                 ...state,
                 ...action.data,
             };
-        case SET_TOP_SHARDS_FILTERS:
+        case SET_SHARD_QUERY_FILTERS:
             return {
                 ...state,
                 filters: {
@@ -151,7 +151,7 @@ export const sendShardQuery = ({database, path = '', sortOrder, filters}: SendSh
                     action: queryAction,
                 },
                 {
-                    concurrentId: 'topShards',
+                    concurrentId: 'shardsWorkload',
                 },
             ),
             actions: SEND_SHARD_QUERY,
@@ -165,16 +165,16 @@ export const sendShardQuery = ({database, path = '', sortOrder, filters}: SendSh
     }
 };
 
-export function setShardQueryOptions(options: Partial<IShardsWorkloadState>) {
+export function setShardsState(options: Partial<IShardsWorkloadState>) {
     return {
-        type: SET_SHARD_QUERY_OPTIONS,
+        type: SET_SHARD_STATE,
         data: options,
     } as const;
 }
 
-export function setTopShardFilters(filters: Partial<IShardsWorkloadFilters>) {
+export function setShardsQueryFilters(filters: Partial<IShardsWorkloadFilters>) {
     return {
-        type: SET_TOP_SHARDS_FILTERS,
+        type: SET_SHARD_QUERY_FILTERS,
         filters,
     } as const;
 }

package/dist/store/reducers/storage.js

@@ -307,6 +307,8 @@ export const getFlatListStorageNodes = createSelector([getStorageNodes], (storag
         return {
             NodeId: node.NodeId,
             FQDN: systemState.Host,
+            DataCenter: systemState.DataCenter,
+            Rack: systemState.Rack,
             uptime: calcUptime(systemState.StartTime),
             StartTime: systemState.StartTime,
             PDisks: node.PDisks,

package/dist/store/reducers/{tablets.js → tablets.ts}

@@ -1,7 +1,20 @@
-import {createRequestActionTypes, createApiRequest} from '../utils';
+import type {Reducer} from 'redux';
 import '../../services/api';
 
-const FETCH_TABLETS = createRequestActionTypes('tablets', 'FETCH_TABLETS');
+import type {ETabletState, EType} from '../../types/api/tablet';
+import type {
+    ITabletsAction,
+    ITabletsApiRequestParams,
+    ITabletsState,
+} from '../../types/store/tablets';
+
+import {createRequestActionTypes, createApiRequest} from '../utils';
+
+export const FETCH_TABLETS = createRequestActionTypes('tablets', 'FETCH_TABLETS');
+
+const CLEAR_WAS_LOADING_TABLETS = 'tablets/CLEAR_WAS_LOADING_TABLETS';
+const SET_STATE_FILTER = 'tablets/SET_STATE_FILTER';
+const SET_TYPE_FILTER = 'tablets/SET_TYPE_FILTER';
 
 const initialState = {
     loading: true,
@@ -10,13 +23,12 @@ const initialState = {
     typeFilter: [],
 };
 
-const tablets = function z(state = initialState, action) {
+const tablets: Reducer<ITabletsState, ITabletsAction> = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_TABLETS.REQUEST: {
             return {
                 ...state,
                 loading: true,
-                requestTime: new Date().getTime(),
             };
         }
         case FETCH_TABLETS.SUCCESS: {
@@ -35,20 +47,20 @@ const tablets = function z(state = initialState, action) {
                 loading: false,
             };
         }
-        case 'CLEAR_WAS_LOADING_TABLETS': {
+        case CLEAR_WAS_LOADING_TABLETS: {
             return {
                 ...state,
                 wasLoaded: false,
                 loading: true,
             };
         }
-        case 'SET_STATE_FILTER': {
+        case SET_STATE_FILTER: {
             return {
                 ...state,
                 stateFilter: action.data,
             };
         }
-        case 'SET_TYPE_FILTER': {
+        case SET_TYPE_FILTER: {
             return {
                 ...state,
                 typeFilter: action.data,
@@ -59,25 +71,26 @@ const tablets = function z(state = initialState, action) {
     }
 };
 
-export const setStateFilter = (stateFilter) => {
+export const setStateFilter = (stateFilter: ETabletState[]) => {
     return {
-        type: 'SET_STATE_FILTER',
+        type: SET_STATE_FILTER,
         data: stateFilter,
-    };
+    } as const;
 };
 
-export const setTypeFilter = (typeFilter) => {
+export const setTypeFilter = (typeFilter: EType[]) => {
     return {
-        type: 'SET_TYPE_FILTER',
+        type: SET_TYPE_FILTER,
         data: typeFilter,
-    };
+    } as const;
 };
 
-export const clearWasLoadingFlag = () => ({
-    type: 'CLEAR_WAS_LOADING_TABLETS',
-});
+export const clearWasLoadingFlag = () =>
+    ({
+        type: CLEAR_WAS_LOADING_TABLETS,
+    } as const);
 
-export function getTabletsInfo(data) {
+export function getTabletsInfo(data: ITabletsApiRequestParams) {
     return createApiRequest({
         request: window.api.getTabletsInfo(data),
         actions: FETCH_TABLETS,

package/dist/store/state-url-mapping.js

@@ -48,14 +48,22 @@ const paramSetup = {
         generalTab: {
             stateKey: 'tenant.diagnosticsTab',
         },
-        topShardsFrom: {
+        shardsDateFrom: {
             stateKey: 'shardsWorkload.filters.from',
             type: 'number',
         },
-        topShardsTo: {
+        shardsDateTo: {
             stateKey: 'shardsWorkload.filters.to',
             type: 'number',
         },
+        topQueriesDateFrom: {
+            stateKey: 'executeTopQueries.filters.from',
+            type: 'number',
+        },
+        topQueriesDateTo: {
+            stateKey: 'executeTopQueries.filters.to',
+            type: 'number',
+        },
     },
 };
 

package/dist/types/api/compute.ts

@@ -0,0 +1,52 @@
+import {EFlag} from './enums';
+import {TEndpoint, TLegacyNodeLocation, TPoolStats} from './nodes';
+import {TMetrics} from './tenant';
+
+// endpoint: viewer/json/compute
+// source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+
+export interface TComputeInfo {
+    Overall: EFlag;
+    Tenants?: TComputeTenantInfo[];
+    Errors?: string[];
+}
+
+interface TComputeTenantInfo {
+    Overall: EFlag;
+    Name: string;
+    Nodes?: TComputeNodeInfo[];
+}
+
+interface TComputeNodeInfo {
+    /** uint64 */
+    StartTime: string;
+    /** uint64 */
+    ChangeTime: string;
+    SystemLocation: TLegacyNodeLocation;
+    /** double */
+    LoadAverage: number[];
+    NumberOfCpus: number;
+    Overall: EFlag;
+    NodeId: number;
+    DataCenter: string;
+    Rack: string;
+    Host: string;
+    Version: string;
+    PoolStats?: TPoolStats[];
+    Endpoints?: TEndpoint[];
+    Roles?: string[];
+    /** uint64 */
+    MemoryUsed?: string;
+    /** uint64 */
+    MemoryLimit?: string;
+    Metrics: TMetrics;
+    Tablets?: TTabletStateInfo[];
+}
+
+// Tablets in compute nodes
+// Types for tabletInfo and tablets inside nodes and storage endpoints are in tablet.ts
+interface TTabletStateInfo {
+    Type: string;
+    State: EFlag;
+    Count: number;
+}

package/dist/types/api/consumer.ts

@@ -0,0 +1,257 @@
+/* eslint-disable camelcase */
+
+/**
+ * endpoint: /json/describe_consumer
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/public/api/protos/ydb_topic.proto
+ *
+ * Original proto file doesn't specify optional fields, so every field is considered optional
+ */
+export interface DescribeConsumerResult {
+    self?: Entry;
+    consumer?: Consumer;
+    partitions?: PartitionInfo[];
+}
+
+/** Partition info types differs for consumer and topic, although they are very similar */
+export interface PartitionInfo {
+    /** int64  */
+    partition_id?: string;
+
+    /** Is partition open for write. */
+    active?: boolean;
+
+    /**
+     * int64
+     *
+     * Ids of partitions which was formed when this partition was split or merged.
+     */
+    child_partition_ids?: string[];
+
+    /**
+     * int64
+     *
+     * Ids of partitions from which this partition was formed by split or merge.
+     */
+    parent_partition_ids?: string[];
+
+    /** Stats for partition, filled only when include_stats in request is true. */
+    partition_stats?: PartitionStats;
+
+    /** Stats for consumer of this partition, filled only when include_stats in request is true. */
+    partition_consumer_stats?: PartitionConsumerStats;
+}
+
+interface PartitionConsumerStats {
+    /**
+     * int64
+     *
+     * Last read offset from this partition.
+     */
+    last_read_offset?: string;
+
+    /**
+     * int64
+     *
+     * Committed offset for this partition.
+     */
+    committed_offset?: string;
+
+    /** Reading this partition read session identifier. */
+    read_session_id?: string;
+
+    /**
+     * google.protobuf.Timestamp
+     *
+     * Timestamp of providing this partition to this session by server.
+     */
+    partition_read_session_create_time?: string;
+
+    /**
+     * google.protobuf.Timestamp
+     *
+     * Timestamp of last read from this partition. */
+    last_read_time?: string;
+
+    /**
+     * google.protobuf.Duration
+     *
+     * Maximum of differences between timestamp of read and write timestamp for all messages, read during last minute.
+     */
+    max_read_time_lag?: string;
+
+    /**
+     * google.protobuf.Duration
+     *
+     * Maximum of differences between write timestamp and create timestamp for all messages, read during last minute.
+     */
+    max_write_time_lag?: string;
+
+    /** How much bytes were read during several windows statistics from this partiton. */
+    bytes_read?: MultipleWindowsStat;
+
+    /** Read session name, provided by client. */
+    reader_name?: string;
+
+    /** Host where read session connected. */
+    connection_node_id?: number;
+}
+
+export interface PartitionStats {
+    /** Partition contains messages with offsets in range [start, end). */
+    partition_offsets?: OffsetsRange;
+
+    /**
+     * int64
+     *
+     * Approximate size of partition.
+     */
+    store_size_bytes?: string;
+
+    /**
+     * google.protobuf.Timestamp
+     *
+     * Timestamp of last write.
+     */
+    last_write_time?: string;
+
+    /**
+     * google.protobuf.Duration
+     *
+     * Maximum of differences between write timestamp and create timestamp for all messages, written during last minute.
+     */
+    max_write_time_lag?: string;
+
+    /** How much bytes were written during several windows in this partition. */
+    bytes_written?: MultipleWindowsStat;
+
+    /** Host where tablet for this partition works. Useful for debugging purposes. */
+    partition_node_id?: number;
+}
+
+interface OffsetsRange {
+    /** int64  */
+    start?: string;
+    /** int64  */
+    end?: string;
+}
+
+export interface Consumer {
+    /** Must have valid not empty name as a key. */
+    name?: string;
+
+    /** Consumer may be marked as 'important'. It means messages for this consumer will never expire due to retention. */
+    important?: boolean;
+
+    /**
+     * google.protobuf.Timestamp
+     *
+     * All messages with smaller server written_at timestamp will be skipped.
+     */
+    read_from?: string;
+
+    /**
+     * List of supported codecs by this consumer.
+     *
+     * supported_codecs on topic must be contained inside this list.
+     */
+    supported_codecs?: SupportedCodecs;
+
+    /** Attributes of consumer */
+    attributes?: Record<string, string>;
+
+    /** Filled only when requested statistics in Describe*Request. */
+    consumer_stats?: ConsumerStats;
+}
+
+interface ConsumerStats {
+    /**
+     * google.protobuf.Timestamp
+     *
+     * Minimal timestamp of last read from partitions.
+     */
+    min_partitions_last_read_time?: string;
+
+    /**
+     * google.protobuf.Duration
+     *
+     * Maximum of differences between timestamp of read and write timestamp for all messages, read during last minute.
+     */
+    max_read_time_lag?: string;
+
+    /**
+     * google.protobuf.Duration
+     *
+     * Maximum of differences between write timestamp and create timestamp for all messages, read during last minute.
+     */
+    max_write_time_lag?: string;
+
+    /** Bytes read stastics. */
+    bytes_read?: MultipleWindowsStat;
+}
+
+export interface MultipleWindowsStat {
+    /** int64  */
+    per_minute?: string;
+    /** int64  */
+    per_hour?: string;
+    /** int64  */
+    per_day?: string;
+}
+
+export interface SupportedCodecs {
+    /** List of supported codecs. */
+    codecs?: number[];
+}
+
+export interface Entry {
+    /** For consumer will be topic-name/consumer-name */
+    name?: string;
+
+    owner?: string;
+    type?: Type;
+    effective_permissions?: Permissions[];
+    permissions?: Permissions[];
+
+    /**
+     * uint64
+     *
+     * Size of entry in bytes. Currently filled for:
+     * - TABLE;
+     * - DATABASE.
+     *
+     * Empty (zero) in other cases.
+     */
+    size_bytes?: string;
+
+    /** Virtual timestamp when the object was created */
+    created_at?: VirtualTimestamp;
+}
+
+interface Permissions {
+    subject?: string;
+    permission_names?: string[];
+}
+
+interface VirtualTimestamp {
+    /** uint64 */
+    plan_step?: string;
+    /** uint64 */
+    tx_id?: string;
+}
+
+enum Type {
+    TYPE_UNSPECIFIED = 'TYPE_UNSPECIFIED',
+    DIRECTORY = 'DIRECTORY',
+    TABLE = 'TABLE',
+    PERS_QUEUE_GROUP = 'PERS_QUEUE_GROUP',
+    DATABASE = 'DATABASE',
+    RTMR_VOLUME = 'RTMR_VOLUME',
+    BLOCK_STORE_VOLUME = 'BLOCK_STORE_VOLUME',
+    COORDINATION_NODE = 'COORDINATION_NODE',
+    COLUMN_STORE = 'COLUMN_STORE ',
+    COLUMN_TABLE = 'COLUMN_TABLE ',
+    SEQUENCE = 'SEQUENCE ',
+    REPLICATION = 'REPLICATION ',
+    TOPIC = 'TOPIC ',
+}