import { Color } from '@signozhq/design-tokens';
import { Tag, Tooltip } from 'antd';
import { ColumnType } from 'antd/es/table';
import {
K8sDeploymentsData,
K8sDeploymentsListPayload,
} from 'api/infraMonitoring/getK8sDeploymentsList';
import { Group } from 'lucide-react';
import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
import {
EntityProgressBar,
formatBytes,
ValidateColumnValueWrapper,
} from '../commonUtils';
import { IEntityColumn } from '../utils';
export const defaultAddedColumns: IEntityColumn[] = [
{
label: 'Deployment Name',
value: 'deploymentName',
id: 'deploymentName',
canRemove: false,
},
{
label: 'Namespace Name',
value: 'namespaceName',
id: 'namespaceName',
canRemove: false,
},
{
label: 'Available',
value: 'available_pods',
id: 'available_pods',
canRemove: false,
},
{
label: 'Desired',
value: 'desired_pods',
id: 'desired_pods',
canRemove: false,
},
{
label: 'CPU Request Utilization (% of limit)',
value: 'cpu_request',
id: 'cpu_request',
canRemove: false,
},
{
label: 'CPU Limit Utilization (% of request)',
value: 'cpu_limit',
id: 'cpu_limit',
canRemove: false,
},
{
label: 'CPU Utilization (cores)',
value: 'cpu',
id: 'cpu',
canRemove: false,
},
{
label: 'Memory Request Utilization (% of limit)',
value: 'memory_request',
id: 'memory_request',
canRemove: false,
},
{
label: 'Memory Limit Utilization (% of request)',
value: 'memory_limit',
id: 'memory_limit',
canRemove: false,
},
{
label: 'Memory Utilization (bytes)',
value: 'memory',
id: 'memory',
canRemove: false,
},
];
export interface K8sDeploymentsRowData {
key: string;
deploymentUID: string;
deploymentName: React.ReactNode;
available_pods: React.ReactNode;
desired_pods: React.ReactNode;
cpu_request: React.ReactNode;
cpu_limit: React.ReactNode;
cpu: React.ReactNode;
memory_request: React.ReactNode;
memory_limit: React.ReactNode;
memory: React.ReactNode;
restarts: React.ReactNode;
clusterName: string;
namespaceName: string;
groupedByMeta?: any;
}
const deploymentGroupColumnConfig = {
title: (
DEPLOYMENT GROUP
),
dataIndex: 'deploymentGroup',
key: 'deploymentGroup',
ellipsis: true,
width: 150,
align: 'left',
sorter: false,
className: 'column entity-group-header',
};
export const getK8sDeploymentsListQuery = (): K8sDeploymentsListPayload => ({
filters: {
items: [],
op: 'and',
},
orderBy: { columnName: 'cpu', order: 'desc' },
});
const columnsConfig = [
{
title: (
Deployment Name
),
dataIndex: 'deploymentName',
key: 'deploymentName',
ellipsis: true,
width: 150,
sorter: false,
align: 'left',
},
{
title: (
Namespace Name
),
dataIndex: 'namespaceName',
key: 'namespaceName',
ellipsis: true,
width: 150,
sorter: false,
align: 'left',
},
{
title: Available
,
dataIndex: 'available_pods',
key: 'available_pods',
width: 100,
sorter: false,
align: 'left',
},
{
title: Desired
,
dataIndex: 'desired_pods',
key: 'desired_pods',
width: 80,
sorter: false,
align: 'left',
},
{
title: CPU Req Usage (%)
,
dataIndex: 'cpu_request',
key: 'cpu_request',
width: 80,
sorter: true,
align: 'left',
},
{
title: CPU Limit Usage (%)
,
dataIndex: 'cpu_limit',
key: 'cpu_limit',
width: 50,
sorter: true,
align: 'left',
},
{
title: CPU Usage (cores)
,
dataIndex: 'cpu',
key: 'cpu',
width: 80,
sorter: true,
align: 'left',
},
{
title: Mem Req Usage (%)
,
dataIndex: 'memory_request',
key: 'memory_request',
width: 50,
sorter: true,
align: 'left',
},
{
title: Mem Limit Usage (%)
,
dataIndex: 'memory_limit',
key: 'memory_limit',
width: 80,
sorter: true,
align: 'left',
},
{
title: Mem Usage
,
dataIndex: 'memory',
key: 'memory',
width: 80,
sorter: true,
align: 'left',
},
];
export const getK8sDeploymentsListColumns = (
groupBy: IBuilderQuery['groupBy'],
): ColumnType[] => {
if (groupBy.length > 0) {
const filteredColumns = [...columnsConfig].filter(
(column) => column.key !== 'deploymentName',
);
filteredColumns.unshift(deploymentGroupColumnConfig);
return filteredColumns as ColumnType[];
}
return columnsConfig as ColumnType[];
};
const dotToUnder: Record = {
'k8s.deployment.name': 'k8s_deployment_name',
'k8s.namespace.name': 'k8s_namespace_name',
'k8s.cluster.name': 'k8s_cluster_name',
};
const getGroupByEle = (
deployment: K8sDeploymentsData,
groupBy: IBuilderQuery['groupBy'],
): React.ReactNode => {
const groupByValues: string[] = [];
groupBy.forEach((group) => {
const rawKey = group.key as string;
// Choose mapped key if present, otherwise use rawKey
const metaKey = (dotToUnder[rawKey] ??
rawKey) as keyof typeof deployment.meta;
const value = deployment.meta[metaKey];
groupByValues.push(value);
});
return (
{groupByValues.map((value) => (
{value === '' ? '' : value}
))}
);
};
export const formatDataForTable = (
data: K8sDeploymentsData[],
groupBy: IBuilderQuery['groupBy'],
): K8sDeploymentsRowData[] =>
data.map((deployment, index) => ({
key: index.toString(),
deploymentUID: deployment.meta.k8s_deployment_name,
deploymentName: (
{deployment.meta.k8s_deployment_name}
),
available_pods: (
{deployment.availablePods}
),
desired_pods: (
{deployment.desiredPods}
),
restarts: (
{deployment.restarts}
),
cpu: (
{deployment.cpuUsage}
),
cpu_request: (
),
cpu_limit: (
),
memory: (
{formatBytes(deployment.memoryUsage)}
),
memory_request: (
),
memory_limit: (
),
clusterName: deployment.meta.k8s_cluster_name,
namespaceName: deployment.meta.k8s_namespace_name,
deploymentGroup: getGroupByEle(deployment, groupBy),
meta: deployment.meta,
...deployment.meta,
groupedByMeta: deployment.meta,
}));