ydb-embedded-ui 3.3.4 → 3.4.0

package/dist/containers/Tenant/Diagnostics/Partitions/columns/columns.tsx

@@ -0,0 +1,246 @@
+import DataTable, {Column} from '@gravity-ui/react-data-table';
+import block from 'bem-cn-lite';
+
+import {SpeedMultiMeter} from '../../../../../components/SpeedMultiMeter';
+import EntityStatus from '../../../../../components/EntityStatus/EntityStatus';
+import {getDefaultNodePath} from '../../../../Node/NodePages';
+import {formatBytes, formatMsToUptime} from '../../../../../utils';
+import {isNumeric} from '../../../../../utils/utils';
+
+import {
+    PARTITIONS_COLUMNS_IDS,
+    PARTITIONS_COLUMNS_TITILES,
+    PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS,
+    PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES,
+    PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS,
+    PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES,
+} from '../utils/constants';
+import type {IPreparedPartitionDataWithHosts} from '../utils/types';
+
+import {
+    MultilineHeader,
+    ReadLagsHeader,
+    ReadSessionHeader,
+    UncommitedMessagesHeader,
+    UnreadMessagesHeader,
+    WriteLagsHeader,
+} from '../Headers';
+
+import './Columns.scss';
+
+const b = block('ydb-diagnostics-partitions-columns');
+
+export const columns: Column<IPreparedPartitionDataWithHosts>[] = [
+    {
+        name: PARTITIONS_COLUMNS_IDS.PARTITION_ID,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.PARTITION_ID]}
+            />
+        ),
+        sortAccessor: (row) => isNumeric(row.partitionId) && Number(row.partitionId),
+        align: DataTable.LEFT,
+        render: ({row}) => row.partitionId,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.STORE_SIZE,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.STORE_SIZE]}
+            />
+        ),
+        align: DataTable.RIGHT,
+        render: ({row}) => formatBytes(row.storeSize),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.WRITE_SPEED,
+        header: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.WRITE_SPEED],
+        align: DataTable.LEFT,
+        sortAccessor: (row) => row.writeSpeed.perMinute,
+        render: ({row}) => <SpeedMultiMeter data={row.writeSpeed} />,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READ_SPEED,
+        header: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.READ_SPEED],
+        align: DataTable.LEFT,
+        sortAccessor: (row) => row.readSpeed.perMinute,
+        render: ({row}) => <SpeedMultiMeter data={row.readSpeed} />,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.WRITE_LAGS,
+        header: <WriteLagsHeader />,
+        className: b('lags-header'),
+        sub: [
+            {
+                name: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_LAG,
+                header: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES[
+                    PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_LAG
+                ],
+                align: DataTable.RIGHT,
+                render: ({row}) => formatMsToUptime(row.partitionWriteLag),
+            },
+            {
+                name: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_IDLE_TIME,
+                header: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES[
+                    PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_IDLE_TIME
+                ],
+                align: DataTable.RIGHT,
+                render: ({row}) => formatMsToUptime(row.partitionWriteIdleTime),
+            },
+        ],
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READ_LAGS,
+        header: <ReadLagsHeader />,
+        className: b('lags-header'),
+        sub: [
+            {
+                name: PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_WRITE_LAG,
+                header: PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES[
+                    PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_WRITE_LAG
+                ],
+                align: DataTable.RIGHT,
+                render: ({row}) => formatMsToUptime(row.consumerWriteLag),
+            },
+            {
+                name: PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_LAG,
+                header: PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES[
+                    PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_LAG
+                ],
+                align: DataTable.RIGHT,
+                render: ({row}) => formatMsToUptime(row.consumerReadLag),
+            },
+            {
+                name: PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_IDLE_TIME,
+                header: PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES[
+                    PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_IDLE_TIME
+                ],
+                align: DataTable.RIGHT,
+                render: ({row}) => formatMsToUptime(row.consumerReadIdleTime),
+            },
+        ],
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.UNCOMMITED_MESSAGES,
+        header: <UncommitedMessagesHeader />,
+        align: DataTable.RIGHT,
+        render: ({row}) => row.uncommitedMessages,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.UNREAD_MESSAGES,
+        header: <UnreadMessagesHeader />,
+        align: DataTable.RIGHT,
+        render: ({row}) => row.unreadMessages,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.START_OFFSET,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.START_OFFSET]}
+            />
+        ),
+        sortAccessor: (row) => isNumeric(row.startOffset) && Number(row.startOffset),
+        align: DataTable.RIGHT,
+        render: ({row}) => row.startOffset,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.END_OFFSET,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.END_OFFSET]}
+            />
+        ),
+        sortAccessor: (row) => isNumeric(row.endOffset) && Number(row.endOffset),
+        align: DataTable.RIGHT,
+        render: ({row}) => row.endOffset,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.COMMITED_OFFSET,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.COMMITED_OFFSET]}
+            />
+        ),
+        sortAccessor: (row) => isNumeric(row.commitedOffset) && Number(row.commitedOffset),
+        align: DataTable.RIGHT,
+        render: ({row}) => row.commitedOffset,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READ_SESSION_ID,
+        header: <ReadSessionHeader />,
+        align: DataTable.LEFT,
+        render: ({row}) =>
+            row.readSessionId ? (
+                <EntityStatus
+                    name={row.readSessionId}
+                    showStatus={false}
+                    hasClipboardButton
+                    className={b('string-with-copy')}
+                />
+            ) : (
+                '–'
+            ),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READER_NAME,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.READER_NAME]}
+            />
+        ),
+        align: DataTable.LEFT,
+        render: ({row}) =>
+            row.readerName ? (
+                <EntityStatus
+                    name={row.readerName}
+                    showStatus={false}
+                    hasClipboardButton
+                    className={b('string-with-copy')}
+                />
+            ) : (
+                '–'
+            ),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.PARTITION_HOST,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.PARTITION_HOST]}
+            />
+        ),
+        align: DataTable.LEFT,
+        render: ({row}) =>
+            row.partitionHost ? (
+                <EntityStatus
+                    name={row.partitionHost}
+                    path={getDefaultNodePath(row.partitionHost)}
+                    showStatus={false}
+                    hasClipboardButton
+                    className={b('string-with-copy')}
+                />
+            ) : (
+                '–'
+            ),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.CONNECTION_HOST,
+        header: (
+            <MultilineHeader
+                title={PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.CONNECTION_HOST]}
+            />
+        ),
+        align: DataTable.LEFT,
+        render: ({row}) =>
+            row.connectionHost ? (
+                <EntityStatus
+                    name={row.connectionHost}
+                    path={getDefaultNodePath(row.connectionNodeId)}
+                    showStatus={false}
+                    hasClipboardButton
+                    className={b('string-with-copy')}
+                />
+            ) : (
+                '–'
+            ),
+    },
+];

package/dist/containers/Tenant/Diagnostics/Partitions/columns/index.ts

@@ -0,0 +1 @@
+export * from './columns';

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/en.json

@@ -0,0 +1,13 @@
+{
+  "lagsPopover.writeLags": "Write lags statistics (time format dd hh:mm:ss)",
+  "lagsPopover.readLags": "Read lags statistics (time format dd hh:mm:ss)",
+  "headers.unread": "End offset - Last read offset",
+  "headers.uncommited": "End offset - Committed offset",
+  "controls.consumerSelector": "Consumer:",
+  "controls.consumerSelector.placeholder": "Consumer",
+  "controls.partitionSearch": "Partition ID",
+  "controls.generalSearch": "Host, Host ID, Reader, Read Session ID",
+  "table.emptyDataMessage": "No partitions match the current search",
+  "noConsumersMessage.topic": "This topic has no consumers",
+  "noConsumersMessage.stream": "This changefeed has no consumers"
+}

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/index.ts

@@ -0,0 +1,11 @@
+import {i18n, Lang} from '../../../../../utils/i18n';
+
+import en from './en.json';
+import ru from './ru.json';
+
+const COMPONENT = 'ydb-diagnostics-partitions';
+
+i18n.registerKeyset(Lang.En, COMPONENT, en);
+i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
+
+export default i18n.keyset(COMPONENT);

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/ru.json

@@ -0,0 +1,13 @@
+{
+  "lagsPopover.writeLags": "Статистика лагов записи (формат времени дд чч:мм:сс)",
+  "lagsPopover.readLags": "Статистика лагов чтения (формат времени дд чч:мм:сс)",
+  "headers.unread": "End offset - Last read offset",
+  "headers.uncommited": "End offset - Committed offset",
+  "controls.consumerSelector": "Читатель:",
+  "controls.consumerSelector.placeholder": "Читатель",
+  "controls.partitionSearch": "Partition ID",
+  "controls.generalSearch": "Host, Host ID, Reader, Read Session ID",
+  "table.emptyDataMessage": "По заданному поиску нет партиций",
+  "noConsumersMessage.topic": "У этого топика нет читателей",
+  "noConsumersMessage.stream": "У этого стрима нет читателей"
+}

package/dist/containers/Tenant/Diagnostics/Partitions/index.ts

@@ -0,0 +1 @@
+export * from './PartitionsWrapper';

package/dist/containers/Tenant/Diagnostics/Partitions/utils/constants.ts

@@ -0,0 +1,74 @@
+export const PARTITIONS_COLUMNS_IDS = {
+    PARTITION_ID: 'partitionId',
+
+    STORE_SIZE: 'storeSize',
+
+    WRITE_SPEED: 'writeSpeed',
+    READ_SPEED: 'readSpeed',
+
+    WRITE_LAGS: 'writeLags',
+    READ_LAGS: 'readLags',
+
+    UNCOMMITED_MESSAGES: 'uncommitedMessages',
+    UNREAD_MESSAGES: 'unreadMessages',
+
+    START_OFFSET: 'startOffset',
+    END_OFFSET: 'endOffset',
+    COMMITED_OFFSET: 'commitedOffset',
+
+    READ_SESSION_ID: 'readSessionId',
+    READER_NAME: 'readerName',
+
+    PARTITION_HOST: 'partitionHost',
+    CONNECTION_HOST: 'connectionHost',
+} as const;
+
+export const PARTITIONS_COLUMNS_TITILES = {
+    [PARTITIONS_COLUMNS_IDS.PARTITION_ID]: 'Partition ID',
+
+    [PARTITIONS_COLUMNS_IDS.STORE_SIZE]: 'Store size',
+
+    [PARTITIONS_COLUMNS_IDS.WRITE_SPEED]: 'Write speed',
+    [PARTITIONS_COLUMNS_IDS.READ_SPEED]: 'Read speed',
+
+    [PARTITIONS_COLUMNS_IDS.WRITE_LAGS]: 'Write lags, duration',
+
+    [PARTITIONS_COLUMNS_IDS.READ_LAGS]: 'Read lags, duration',
+
+    [PARTITIONS_COLUMNS_IDS.UNCOMMITED_MESSAGES]: 'Uncommited messages',
+    [PARTITIONS_COLUMNS_IDS.UNREAD_MESSAGES]: 'Unread messages',
+
+    [PARTITIONS_COLUMNS_IDS.START_OFFSET]: 'Start offset',
+    [PARTITIONS_COLUMNS_IDS.END_OFFSET]: 'End offset',
+    [PARTITIONS_COLUMNS_IDS.COMMITED_OFFSET]: 'Commited offset',
+
+    [PARTITIONS_COLUMNS_IDS.READ_SESSION_ID]: 'Read session ID',
+    [PARTITIONS_COLUMNS_IDS.READER_NAME]: 'Reader name',
+
+    [PARTITIONS_COLUMNS_IDS.PARTITION_HOST]: 'Partition host',
+    [PARTITIONS_COLUMNS_IDS.CONNECTION_HOST]: 'Connection host',
+} as const;
+
+export const PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS = {
+    PARTITION_WRITE_LAG: 'partitionWriteLag',
+    PARTITION_WRITE_IDLE_TIME: 'partitionWriteIdleTime',
+} as const;
+
+export const PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES = {
+    [PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_LAG]: 'write lag',
+    [PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_IDLE_TIME]: 'write idle time',
+} as const;
+
+export const PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS = {
+    CONSUMER_WRITE_LAG: 'consumerWriteLag',
+    CONSUMER_READ_LAG: 'consumerReadLag',
+    CONSUMER_READ_IDLE_TIME: 'consumerReadIdleTime',
+} as const;
+
+export const PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES = {
+    [PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_WRITE_LAG]: 'write lag',
+    [PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_LAG]: 'read lag',
+    [PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_IDLE_TIME]: 'read idle time',
+} as const;
+
+export const PARTITIONS_DEFAULT_SELECTED_COLUMNS = Object.values(PARTITIONS_COLUMNS_IDS);

package/dist/containers/Tenant/Diagnostics/Partitions/utils/types.ts

@@ -0,0 +1,6 @@
+import type {IPreparedPartitionData} from '../../../../../types/store/consumer';
+
+export interface IPreparedPartitionDataWithHosts extends IPreparedPartitionData {
+    partitionHost: string | undefined;
+    connectionHost: string | undefined;
+}

package/dist/containers/Tenant/utils/schema.ts

@@ -155,22 +155,7 @@ export const isDatabaseEntityType = (type?: EPathType) =>
 
 // ====================
 
-const pathTypeToIsCdcStream: Record<EPathType, boolean> = {
-    [EPathType.EPathTypeCdcStream]: true,
-
-    [EPathType.EPathTypeInvalid]: false,
-    [EPathType.EPathTypeColumnStore]: false,
-    [EPathType.EPathTypeColumnTable]: false,
-    [EPathType.EPathTypeDir]: false,
-    [EPathType.EPathTypeTable]: false,
-    [EPathType.EPathTypeSubDomain]: false,
-    [EPathType.EPathTypeTableIndex]: false,
-    [EPathType.EPathTypeExtSubDomain]: false,
-    [EPathType.EPathTypePersQueueGroup]: false,
-};
-
-export const isCdcStreamEntityType = (type?: EPathType) =>
-    (type && pathTypeToIsCdcStream[type]) ?? false;
+export const isCdcStreamEntityType = (type?: EPathType) => type === EPathType.EPathTypeCdcStream;
 
 // ====================
 

package/dist/services/api.d.ts

@@ -62,6 +62,10 @@ interface Window {
         getTopic: (params: {
             path?: string;
         }) => Promise<import('../types/api/topic').DescribeTopicResult>;
+        getConsumer: (params: {
+            path?: string;
+            consumer?: string;
+        }) => Promise<import('../types/api/consumer').DescribeConsumerResult>;
         [method: string]: Function;
     };
 }

package/dist/services/api.js

@@ -141,12 +141,28 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             path,
         });
     }
-    getTopic({path}) {
-        return this.get(this.getPath('/viewer/json/describe_topic'), {
-            enums: true,
-            include_stats: true,
-            path,
-        });
+    getTopic({path}, {concurrentId} = {}) {
+        return this.get(
+            this.getPath('/viewer/json/describe_topic'),
+            {
+                enums: true,
+                include_stats: true,
+                path,
+            },
+            {concurrentId: concurrentId || 'getTopic'},
+        );
+    }
+    getConsumer({path, consumer}, {concurrentId} = {}) {
+        return this.get(
+            this.getPath('/viewer/json/describe_consumer'),
+            {
+                enums: true,
+                include_stats: true,
+                path,
+                consumer,
+            },
+            {concurrentId: concurrentId || 'getConsumer'},
+        );
     }
     getPoolInfo(poolName) {
         return this.get(this.getPath('/viewer/json/storage'), {

package/dist/store/reducers/consumer.ts

@@ -0,0 +1,160 @@
+/* eslint-disable camelcase */
+import type {Reducer} from 'redux';
+import {createSelector, Selector} from 'reselect';
+
+import type {
+    IConsumerAction,
+    IConsumerRootStateSlice,
+    IConsumerState,
+    IPreparedPartitionData,
+} from '../../types/store/consumer';
+
+import '../../services/api';
+
+import {convertBytesObjectToSpeed} from '../../utils/bytesParsers';
+import {parseLag, parseTimestampToIdleTime} from '../../utils/timeParsers';
+import {isNumeric} from '../../utils/utils';
+
+import {createRequestActionTypes, createApiRequest} from '../utils';
+
+export const FETCH_CONSUMER = createRequestActionTypes('consumer', 'FETCH_CONSUMER');
+
+const SET_DATA_WAS_NOT_LOADED = 'consumer/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    data: {},
+};
+
+const consumer: Reducer<IConsumerState, IConsumerAction> = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_CONSUMER.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_CONSUMER.SUCCESS: {
+            // On older version it can return HTML page of Internal Viewer with an error
+            if (typeof action.data !== 'object') {
+                return {...state, loading: false, error: {}};
+            }
+
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_CONSUMER.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+};
+
+export function getConsumer(path?: string, consumerName?: string) {
+    return createApiRequest({
+        request: window.api.getConsumer({path, consumer: consumerName}),
+        actions: FETCH_CONSUMER,
+    });
+}
+
+export const selectPartitions = (state: IConsumerRootStateSlice) => state.consumer.data?.partitions;
+
+export const selectPreparedPartitionsData: Selector<
+    IConsumerRootStateSlice,
+    IPreparedPartitionData[] | undefined
+> = createSelector([selectPartitions], (partitions) => {
+    return partitions?.map((partition) => {
+        // describe_consumer endpoint doesn't return zero values, so some values will be initialized with 0
+        const {partition_id = '0', partition_stats, partition_consumer_stats} = partition;
+
+        const {
+            partition_offsets,
+            store_size_bytes = '0',
+            last_write_time: partition_last_write_time,
+            max_write_time_lag: partition_write_lag,
+            bytes_written,
+            partition_node_id = 0,
+        } = partition_stats || {};
+
+        const {start: start_offset = '0', end: end_offset = '0'} = partition_offsets || {};
+
+        const {
+            last_read_offset = '0',
+            committed_offset = '0',
+            read_session_id,
+            last_read_time: consumer_last_read_time,
+            max_read_time_lag: consumer_read_lag,
+            max_write_time_lag: consumer_write_lag,
+            bytes_read,
+            reader_name,
+            connection_node_id = 0,
+        } = partition_consumer_stats || {};
+
+        const uncommitedMessages =
+            isNumeric(end_offset) && isNumeric(committed_offset)
+                ? Number(end_offset) - Number(committed_offset)
+                : 0;
+
+        const unreadMessages =
+            isNumeric(end_offset) && isNumeric(last_read_offset)
+                ? Number(end_offset) - Number(last_read_offset)
+                : 0;
+
+        return {
+            partitionId: partition_id,
+            storeSize: store_size_bytes,
+
+            writeSpeed: convertBytesObjectToSpeed(bytes_written),
+            readSpeed: convertBytesObjectToSpeed(bytes_read),
+
+            partitionWriteLag: parseLag(partition_write_lag),
+            partitionWriteIdleTime: parseTimestampToIdleTime(partition_last_write_time),
+
+            consumerWriteLag: parseLag(consumer_write_lag),
+            consumerReadLag: parseLag(consumer_read_lag),
+            consumerReadIdleTime: parseTimestampToIdleTime(consumer_last_read_time),
+
+            uncommitedMessages,
+            unreadMessages,
+
+            startOffset: start_offset,
+            endOffset: end_offset,
+            commitedOffset: committed_offset,
+
+            readSessionId: read_session_id,
+            readerName: reader_name,
+
+            partitionNodeId: partition_node_id,
+            connectionNodeId: connection_node_id,
+        };
+    });
+});
+
+export default consumer;

package/dist/store/reducers/index.ts

@@ -18,6 +18,7 @@ import pool from './pool';
 import tenants from './tenants';
 import tablet from './tablet';
 import topic from './topic';
+import consumer from './consumer';
 import executeQuery from './executeQuery';
 import explainQuery from './explainQuery';
 import tabletsFilters from './tabletsFilters';
@@ -57,6 +58,7 @@ export const rootReducer = {
     tenants,
     tablet,
     topic,
+    consumer,
     executeQuery,
     explainQuery,
     tabletsFilters,

package/dist/store/reducers/settings.js

@@ -7,6 +7,7 @@ import {
     INVERTED_DISKS_KEY,
     ASIDE_HEADER_COMPACT_KEY,
     USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY,
+    PARTITIONS_SELECTED_COLUMNS_KEY,
 } from '../../utils/constants';
 import '../../services/api';
 import {getValueFromLS} from '../../utils/utils';
@@ -50,6 +51,7 @@ export const initialState = {
             ASIDE_HEADER_COMPACT_KEY,
             legacyAsideNavCompactState || 'true',
         ),
+        [PARTITIONS_SELECTED_COLUMNS_KEY]: readSavedSettingsValue(PARTITIONS_SELECTED_COLUMNS_KEY),
     },
     systemSettings,
 };