@oneuptime/common 11.6.1 → 11.6.2

package/build/dist/Models/AnalyticsModels/KubernetesCostAllocation.js

@@ -0,0 +1,713 @@
+import AnalyticsBaseModel from "./AnalyticsBaseModel/AnalyticsBaseModel";
+import Route from "../../Types/API/Route";
+import AnalyticsTableEngine from "../../Types/AnalyticsDatabase/AnalyticsTableEngine";
+import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
+import AnalyticsTableColumn, { SkipIndexType, } from "../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+import Permission from "../../Types/Permission";
+/*
+ * One cost-allocation record for a Kubernetes workload over a time window,
+ * as computed by an in-cluster cost engine (OpenCost / Kubecost cost-model)
+ * and shipped by the OneUptime Kubernetes agent's cost poller. Each row is
+ * one (cluster, window, namespace, controller, pod, container) slice with
+ * pre-priced cpu/ram/gpu/pv/network/load-balancer cost components and
+ * request-vs-usage efficiency ratios.
+ *
+ * Idle and unallocated capacity arrive as regular rows whose namespace is
+ * the engine's sentinel ("__idle__" / "__unallocated__"), so idle spend is
+ * queryable with the same GROUP BY as workload spend.
+ *
+ * Access control mirrors the KubernetesCluster database model — cost rows
+ * are an attribute of the cluster they were metered on.
+ */
+const readPermissions = [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.Viewer,
+    Permission.SettingsAdmin,
+    Permission.SettingsMember,
+    Permission.SettingsViewer,
+    Permission.ReadKubernetesCluster,
+];
+const createPermissions = [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.SettingsAdmin,
+    Permission.SettingsMember,
+    Permission.CreateKubernetesCluster,
+];
+const deletePermissions = [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.SettingsAdmin,
+    Permission.SettingsMember,
+    Permission.DeleteKubernetesCluster,
+];
+export default class KubernetesCostAllocation extends AnalyticsBaseModel {
+    constructor() {
+        const projectIdColumn = new AnalyticsTableColumn({
+            key: "projectId",
+            title: "Project ID",
+            description: "ID of project",
+            required: true,
+            type: TableColumnType.ObjectID,
+            isTenantId: true,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const kubernetesClusterIdColumn = new AnalyticsTableColumn({
+            key: "kubernetesClusterId",
+            title: "Kubernetes Cluster ID",
+            description: "ID of the KubernetesCluster this cost row was metered on. Resolved at ingest from the cluster name (findOrCreateByClusterIdentifier), so every stored row has one.",
+            required: true,
+            type: TableColumnType.ObjectID,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const clusterNameColumn = new AnalyticsTableColumn({
+            key: "clusterName",
+            title: "Cluster Name",
+            description: "Cluster identifier as reported by the agent (matches KubernetesCluster.clusterIdentifier and the resource.k8s.cluster.name metric attribute).",
+            required: true,
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_cluster_name",
+                type: SkipIndexType.Set,
+                params: [100],
+                granularity: 4,
+            },
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const k8sClusterEntityKeyColumn = new AnalyticsTableColumn({
+            key: "k8sClusterEntityKey",
+            title: "Kubernetes Cluster Entity Key",
+            description: "Stable 16-hex entity key of the cluster (see Common/Utils/Telemetry/EntityKey.keyForKubernetesCluster); joins cost rows to the metric rollups keyed by the same column.",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            codec: { codec: "ZSTD", level: 1 },
+            skipIndex: {
+                name: "idx_k8s_cluster_entity_key",
+                type: SkipIndexType.BloomFilter,
+                params: [0.01],
+                granularity: 1,
+            },
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const windowStartColumn = new AnalyticsTableColumn({
+            key: "windowStart",
+            codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
+            title: "Window Start",
+            description: "Start of the allocation window this row covers.",
+            required: true,
+            type: TableColumnType.DateTime64,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const windowEndColumn = new AnalyticsTableColumn({
+            key: "windowEnd",
+            codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
+            title: "Window End",
+            description: "End of the allocation window this row covers.",
+            required: true,
+            type: TableColumnType.DateTime64,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const namespaceColumn = new AnalyticsTableColumn({
+            key: "namespace",
+            title: "Namespace",
+            description: 'Kubernetes namespace of the workload. Engine sentinels ("__idle__", "__unallocated__") mark non-workload capacity.',
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_namespace",
+                type: SkipIndexType.Set,
+                params: [100],
+                granularity: 4,
+            },
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const controllerKindColumn = new AnalyticsTableColumn({
+            key: "controllerKind",
+            isLowCardinality: true,
+            title: "Controller Kind",
+            description: "Kind of the owning controller (deployment / statefulset / daemonset / job / cronjob / replicaset / pod).",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const controllerNameColumn = new AnalyticsTableColumn({
+            key: "controllerName",
+            title: "Controller Name",
+            description: "Name of the owning controller (the workload).",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_controller_name",
+                type: SkipIndexType.BloomFilter,
+                params: [0.01],
+                granularity: 1,
+            },
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const podNameColumn = new AnalyticsTableColumn({
+            key: "podName",
+            title: "Pod Name",
+            description: "Name of the pod, when the row is pod- or container-level.",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_pod_name",
+                type: SkipIndexType.BloomFilter,
+                params: [0.01],
+                granularity: 1,
+            },
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const containerNameColumn = new AnalyticsTableColumn({
+            key: "containerName",
+            title: "Container Name",
+            description: "Name of the container, when the row is container-level.",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const nodeNameColumn = new AnalyticsTableColumn({
+            key: "nodeName",
+            title: "Node Name",
+            description: "Node the workload ran on during the window.",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_node_name",
+                type: SkipIndexType.BloomFilter,
+                params: [0.01],
+                granularity: 1,
+            },
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const providerIdColumn = new AnalyticsTableColumn({
+            key: "providerId",
+            title: "Provider ID",
+            description: "Cloud provider instance identifier of the node, when known.",
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const labelsColumn = new AnalyticsTableColumn({
+            key: "labels",
+            codec: { codec: "ZSTD", level: 3 },
+            title: "Labels",
+            description: "Kubernetes labels of the workload (merged pod/namespace labels as reported by the cost engine). Enables cost-by-label (team / app / env) queries.",
+            required: true,
+            defaultValue: {},
+            type: TableColumnType.MapStringString,
+            mapKeysColumn: "labelKeys",
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const labelKeysColumn = new AnalyticsTableColumn({
+            key: "labelKeys",
+            codec: { codec: "ZSTD", level: 3 },
+            title: "Label Keys",
+            description: "Label keys extracted from labels",
+            required: true,
+            defaultValue: [],
+            type: TableColumnType.ArrayText,
+            skipIndex: {
+                name: "idx_label_keys",
+                type: SkipIndexType.BloomFilter,
+                params: [0.01],
+                granularity: 1,
+            },
+            accessControl: labelsColumn.accessControl,
+        });
+        /*
+         * Cost / usage / efficiency measures. All Float64 (Decimal), non-Nullable
+         * with a 0 default — the ingest service always writes every measure, and
+         * non-Nullable keeps sum()/avg() aggregations state-free.
+         */
+        const measureColumns = [
+            {
+                key: "cpuCoreHours",
+                title: "CPU Core Hours",
+                description: "CPU core-hours allocated over the window.",
+            },
+            {
+                key: "cpuCoreRequestAverage",
+                title: "CPU Core Request Average",
+                description: "Average CPU cores requested over the window.",
+            },
+            {
+                key: "cpuCoreUsageAverage",
+                title: "CPU Core Usage Average",
+                description: "Average CPU cores actually used over the window.",
+            },
+            {
+                key: "cpuCost",
+                title: "CPU Cost",
+                description: "Cost of allocated CPU over the window.",
+            },
+            {
+                key: "gpuHours",
+                title: "GPU Hours",
+                description: "GPU-hours allocated over the window.",
+            },
+            {
+                key: "gpuCost",
+                title: "GPU Cost",
+                description: "Cost of allocated GPUs over the window.",
+            },
+            {
+                key: "ramByteHours",
+                title: "RAM Byte Hours",
+                description: "RAM byte-hours allocated over the window.",
+            },
+            {
+                key: "ramBytesRequestAverage",
+                title: "RAM Bytes Request Average",
+                description: "Average RAM bytes requested over the window.",
+            },
+            {
+                key: "ramBytesUsageAverage",
+                title: "RAM Bytes Usage Average",
+                description: "Average RAM bytes actually used over the window.",
+            },
+            {
+                key: "ramCost",
+                title: "RAM Cost",
+                description: "Cost of allocated RAM over the window.",
+            },
+            {
+                key: "pvByteHours",
+                title: "PV Byte Hours",
+                description: "Persistent-volume byte-hours allocated over the window.",
+            },
+            {
+                key: "pvCost",
+                title: "PV Cost",
+                description: "Cost of persistent volumes over the window.",
+            },
+            {
+                key: "networkCost",
+                title: "Network Cost",
+                description: "Network egress cost over the window.",
+            },
+            {
+                key: "loadBalancerCost",
+                title: "Load Balancer Cost",
+                description: "Load balancer cost over the window.",
+            },
+            {
+                key: "sharedCost",
+                title: "Shared Cost",
+                description: "Share of cluster overhead distributed to this workload.",
+            },
+            {
+                key: "externalCost",
+                title: "External Cost",
+                description: "Out-of-cluster cost attributed to this workload, when the engine reports one.",
+            },
+            {
+                key: "totalCost",
+                title: "Total Cost",
+                description: "Total cost of the row over the window (all components).",
+            },
+            {
+                key: "cpuEfficiency",
+                title: "CPU Efficiency",
+                description: "CPU usage / request ratio over the window (0..1+).",
+            },
+            {
+                key: "ramEfficiency",
+                title: "RAM Efficiency",
+                description: "RAM usage / request ratio over the window (0..1+).",
+            },
+            {
+                key: "totalEfficiency",
+                title: "Total Efficiency",
+                description: "Cost-weighted cpu+ram efficiency over the window (0..1+).",
+            },
+        ].map((def) => {
+            return new AnalyticsTableColumn({
+                key: def.key,
+                title: def.title,
+                description: def.description,
+                required: true,
+                defaultValue: 0,
+                type: TableColumnType.Decimal,
+                codec: [{ codec: "Gorilla" }, { codec: "ZSTD", level: 1 }],
+                accessControl: {
+                    read: readPermissions,
+                    create: createPermissions,
+                    update: [],
+                },
+            });
+        });
+        const currencyColumn = new AnalyticsTableColumn({
+            key: "currency",
+            isLowCardinality: true,
+            title: "Currency",
+            description: 'Currency code of the cost figures as configured in the cost engine (e.g. "USD"). Empty when the engine reports none — treat as USD.',
+            required: true,
+            defaultValue: "",
+            type: TableColumnType.Text,
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+            },
+        });
+        const retentionDateColumn = new AnalyticsTableColumn({
+            key: "retentionDate",
+            codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
+            title: "Retention Date",
+            description: "Date after which this row is eligible for TTL deletion, computed at ingest time as windowStart + the cluster's (or project's) telemetry retention days",
+            required: true,
+            type: TableColumnType.Date,
+            defaultValue: undefined,
+        });
+        super({
+            tableName: AnalyticsTableName.KubernetesCostAllocation,
+            tableEngine: AnalyticsTableEngine.MergeTree,
+            singularName: "Kubernetes Cost Allocation",
+            pluralName: "Kubernetes Cost Allocations",
+            accessControl: {
+                read: readPermissions,
+                create: createPermissions,
+                update: [],
+                delete: deletePermissions,
+            },
+            crudApiPath: new Route("/kubernetes-cost-allocation"),
+            enableMCP: true,
+            enableDocumentation: true,
+            tableDescription: "Kubernetes cost allocations — pre-priced cpu/ram/gpu/pv/network cost per workload per time window, as computed by an in-cluster cost engine (OpenCost / Kubecost) and shipped by the OneUptime Kubernetes agent. Query spend by cluster, namespace, controller, pod, or label over time.",
+            tableColumns: [
+                projectIdColumn,
+                kubernetesClusterIdColumn,
+                clusterNameColumn,
+                k8sClusterEntityKeyColumn,
+                windowStartColumn,
+                windowEndColumn,
+                namespaceColumn,
+                controllerKindColumn,
+                controllerNameColumn,
+                podNameColumn,
+                containerNameColumn,
+                nodeNameColumn,
+                providerIdColumn,
+                labelsColumn,
+                labelKeysColumn,
+                ...measureColumns,
+                currencyColumn,
+                retentionDateColumn,
+            ],
+            sortKeys: [
+                "projectId",
+                "kubernetesClusterId",
+                "windowStart",
+                "namespace",
+            ],
+            primaryKeys: [
+                "projectId",
+                "kubernetesClusterId",
+                "windowStart",
+                "namespace",
+            ],
+            partitionKey: "toYYYYMMDD(windowStart)",
+            /*
+             * Shard by cluster so one cluster's cost rows co-locate (every query
+             * filters by cluster or fans out across all of a project's clusters).
+             */
+            shardingKey: "cityHash64(projectId, kubernetesClusterId)",
+            tableSettings: "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
+            ttlExpression: "retentionDate DELETE",
+            defaultSortColumn: "windowStart",
+        });
+    }
+    get projectId() {
+        return this.getColumnValue("projectId");
+    }
+    set projectId(v) {
+        this.setColumnValue("projectId", v);
+    }
+    get kubernetesClusterId() {
+        return this.getColumnValue("kubernetesClusterId");
+    }
+    set kubernetesClusterId(v) {
+        this.setColumnValue("kubernetesClusterId", v);
+    }
+    get clusterName() {
+        return this.getColumnValue("clusterName");
+    }
+    set clusterName(v) {
+        this.setColumnValue("clusterName", v);
+    }
+    get k8sClusterEntityKey() {
+        return this.getColumnValue("k8sClusterEntityKey");
+    }
+    set k8sClusterEntityKey(v) {
+        this.setColumnValue("k8sClusterEntityKey", v);
+    }
+    get windowStart() {
+        return this.getColumnValue("windowStart");
+    }
+    set windowStart(v) {
+        this.setColumnValue("windowStart", v);
+    }
+    get windowEnd() {
+        return this.getColumnValue("windowEnd");
+    }
+    set windowEnd(v) {
+        this.setColumnValue("windowEnd", v);
+    }
+    get namespace() {
+        return this.getColumnValue("namespace");
+    }
+    set namespace(v) {
+        this.setColumnValue("namespace", v);
+    }
+    get controllerKind() {
+        return this.getColumnValue("controllerKind");
+    }
+    set controllerKind(v) {
+        this.setColumnValue("controllerKind", v);
+    }
+    get controllerName() {
+        return this.getColumnValue("controllerName");
+    }
+    set controllerName(v) {
+        this.setColumnValue("controllerName", v);
+    }
+    get podName() {
+        return this.getColumnValue("podName");
+    }
+    set podName(v) {
+        this.setColumnValue("podName", v);
+    }
+    get containerName() {
+        return this.getColumnValue("containerName");
+    }
+    set containerName(v) {
+        this.setColumnValue("containerName", v);
+    }
+    get nodeName() {
+        return this.getColumnValue("nodeName");
+    }
+    set nodeName(v) {
+        this.setColumnValue("nodeName", v);
+    }
+    get providerId() {
+        return this.getColumnValue("providerId");
+    }
+    set providerId(v) {
+        this.setColumnValue("providerId", v);
+    }
+    get labels() {
+        return this.getColumnValue("labels");
+    }
+    set labels(v) {
+        this.setColumnValue("labels", v);
+    }
+    get labelKeys() {
+        return this.getColumnValue("labelKeys");
+    }
+    set labelKeys(v) {
+        this.setColumnValue("labelKeys", v);
+    }
+    get cpuCoreHours() {
+        return this.getColumnValue("cpuCoreHours");
+    }
+    set cpuCoreHours(v) {
+        this.setColumnValue("cpuCoreHours", v);
+    }
+    get cpuCoreRequestAverage() {
+        return this.getColumnValue("cpuCoreRequestAverage");
+    }
+    set cpuCoreRequestAverage(v) {
+        this.setColumnValue("cpuCoreRequestAverage", v);
+    }
+    get cpuCoreUsageAverage() {
+        return this.getColumnValue("cpuCoreUsageAverage");
+    }
+    set cpuCoreUsageAverage(v) {
+        this.setColumnValue("cpuCoreUsageAverage", v);
+    }
+    get cpuCost() {
+        return this.getColumnValue("cpuCost");
+    }
+    set cpuCost(v) {
+        this.setColumnValue("cpuCost", v);
+    }
+    get gpuHours() {
+        return this.getColumnValue("gpuHours");
+    }
+    set gpuHours(v) {
+        this.setColumnValue("gpuHours", v);
+    }
+    get gpuCost() {
+        return this.getColumnValue("gpuCost");
+    }
+    set gpuCost(v) {
+        this.setColumnValue("gpuCost", v);
+    }
+    get ramByteHours() {
+        return this.getColumnValue("ramByteHours");
+    }
+    set ramByteHours(v) {
+        this.setColumnValue("ramByteHours", v);
+    }
+    get ramBytesRequestAverage() {
+        return this.getColumnValue("ramBytesRequestAverage");
+    }
+    set ramBytesRequestAverage(v) {
+        this.setColumnValue("ramBytesRequestAverage", v);
+    }
+    get ramBytesUsageAverage() {
+        return this.getColumnValue("ramBytesUsageAverage");
+    }
+    set ramBytesUsageAverage(v) {
+        this.setColumnValue("ramBytesUsageAverage", v);
+    }
+    get ramCost() {
+        return this.getColumnValue("ramCost");
+    }
+    set ramCost(v) {
+        this.setColumnValue("ramCost", v);
+    }
+    get pvByteHours() {
+        return this.getColumnValue("pvByteHours");
+    }
+    set pvByteHours(v) {
+        this.setColumnValue("pvByteHours", v);
+    }
+    get pvCost() {
+        return this.getColumnValue("pvCost");
+    }
+    set pvCost(v) {
+        this.setColumnValue("pvCost", v);
+    }
+    get networkCost() {
+        return this.getColumnValue("networkCost");
+    }
+    set networkCost(v) {
+        this.setColumnValue("networkCost", v);
+    }
+    get loadBalancerCost() {
+        return this.getColumnValue("loadBalancerCost");
+    }
+    set loadBalancerCost(v) {
+        this.setColumnValue("loadBalancerCost", v);
+    }
+    get sharedCost() {
+        return this.getColumnValue("sharedCost");
+    }
+    set sharedCost(v) {
+        this.setColumnValue("sharedCost", v);
+    }
+    get externalCost() {
+        return this.getColumnValue("externalCost");
+    }
+    set externalCost(v) {
+        this.setColumnValue("externalCost", v);
+    }
+    get totalCost() {
+        return this.getColumnValue("totalCost");
+    }
+    set totalCost(v) {
+        this.setColumnValue("totalCost", v);
+    }
+    get cpuEfficiency() {
+        return this.getColumnValue("cpuEfficiency");
+    }
+    set cpuEfficiency(v) {
+        this.setColumnValue("cpuEfficiency", v);
+    }
+    get ramEfficiency() {
+        return this.getColumnValue("ramEfficiency");
+    }
+    set ramEfficiency(v) {
+        this.setColumnValue("ramEfficiency", v);
+    }
+    get totalEfficiency() {
+        return this.getColumnValue("totalEfficiency");
+    }
+    set totalEfficiency(v) {
+        this.setColumnValue("totalEfficiency", v);
+    }
+    get currency() {
+        return this.getColumnValue("currency");
+    }
+    set currency(v) {
+        this.setColumnValue("currency", v);
+    }
+    get retentionDate() {
+        return this.getColumnValue("retentionDate");
+    }
+    set retentionDate(v) {
+        this.setColumnValue("retentionDate", v);
+    }
+}
+//# sourceMappingURL=KubernetesCostAllocation.js.map