feat(4544): change condition for auto-approva

app/app/private-cloud/products/(product)/[licencePlate]/usage/page.tsx

@@ -81,7 +81,6 @@ export default privateCloudProductUsageMetrics(({ getPathParams }) => {
       containerName: 'Container name',
       usage: { cpu: 'CPU usage', memory: 'Memory usage' },
       requests: { cpu: 'CPU request', memory: 'Memory request' },
-      limits: { cpu: 'CPU limits', memory: 'Memory limits' },
     },
     ...transformPodData(data.podMetrics),
   ];

app/helpers/auto-approval-check.ts

@@ -21,14 +21,14 @@ function checkAutoApprovalEligibility({ allocation, deployment, resourceType }:
   if (deployment.usage === -1) return false;
 
   // Calculate usage-to-limit and utilization ratios
-  const usageRatio = deployment.usage / allocation.limit;
+  const usageRatio = deployment.usage / allocation.request;
   if (resourceType === ResourceType.storage) {
     // Approve if storage usage exceeds 80% of limit
     return usageRatio > 0.8;
   }
-  const utilizationRate = deployment.usage / deployment.request;
-  // Approve CPU/Memory if usage exceeds 85% of limit and utilization is at least 35%
-  return usageRatio > 0.85 && utilizationRate >= 0.35;
+  const utilizationRate = deployment.usage / allocation.request;
+  // Approve CPU/Memory if utilization is at least 35%
+  return utilizationRate >= 0.35;
 }
 
 function extractResourceRequests(resourceRequests: ResourceRequestsEnv) {

app/helpers/resource-metrics.ts

@@ -28,10 +28,6 @@ export type Container = {
     cpu: number;
     memory: number;
   };
-  limits: {
-    cpu: number;
-    memory: number;
-  };
 };
 
 // Conversion factors for resource units
@@ -148,14 +144,12 @@ export function formatCpu(millicores: number) {
 export const getTotalMetrics = (data: Pod[] | PVC[], resource: ResourceType) => {
   let totalUsage = 0;
   let totalRequest = 0;
-  let totalLimit = 0;
   // Iterate through each pod and each container
   if (data.every((item) => 'containers' in item) && (resource === 'cpu' || resource === 'memory')) {
     (data as Pod[]).forEach((pod) => {
       pod.containers.forEach((container) => {
         totalUsage += container.usage[resource] || 0;
         totalRequest += container.requests[resource] || 0;
-        totalLimit += container.limits[resource] || 0;
       });
     });
   } else {
@@ -165,7 +159,7 @@ export const getTotalMetrics = (data: Pod[] | PVC[], resource: ResourceType) =>
       if (pvc.requests) totalRequest += pvc.requests;
     });
   }
-  return { totalUsage, totalRequest, totalLimit };
+  return { totalUsage, totalRequest };
 };
 
 export type TransformedPodData = {
@@ -179,10 +173,6 @@ export type TransformedPodData = {
     cpu: number | string;
     memory: number | string;
   };
-  limits: {
-    cpu: number | string;
-    memory: number | string;
-  };
 };
 
 export type TransformedPVCData = {
@@ -224,10 +214,6 @@ export function transformPodData(data: Pod[]) {
           cpu: container.requests.cpu,
           memory: container.requests.memory,
         },
-        limits: {
-          cpu: container.limits.cpu,
-          memory: container.limits.memory,
-        },
       });
     });
   });

app/services/k8s/resource-details.ts

@@ -39,17 +39,15 @@ export async function getResourceDetails({
   const isStorage = resourceName === ResourceType.storage;
   const namespaceData = await getPodMetrics(licencePlate, env, cluster);
   const metricsData = isStorage ? namespaceData.pvcMetrics : namespaceData.podMetrics;
-
   if (metricsData.length === 0) return result;
 
-  const { totalRequest, totalLimit, totalUsage } = getTotalMetrics(metricsData, resourceName);
+  const { totalRequest, totalUsage } = getTotalMetrics(metricsData, resourceName);
   result.deployment.request = totalRequest;
-  result.deployment.limit = totalLimit;
   result.deployment.usage = totalUsage;
 
   const unitMultiplier = resourceName === 'cpu' ? cpuCoreToMillicoreMultiplier : memoryUnitMultipliers.Gi;
   const resourceValue = currentResourceRequests[env][resourceName];
-  const deploymentRequest = isStorage ? 0 : resourceValue * unitMultiplier;
+  const deploymentRequest = resourceValue * unitMultiplier;
 
   result.allocation.request = deploymentRequest;
   return result;

app/services/k8s/usage-metrics.ts

@@ -67,6 +67,7 @@ async function collectPVCMetrics(namespace: string, cluster: Cluster) {
   const { apiClient } = getK8sClients(cluster);
   const res = await apiClient.listNamespacedPersistentVolumeClaim(namespace);
   const pvcs = res.body.items;
+
   const pvcPromises = pvcs.map(async (pvc) => {
     const pvcName = pvc.metadata?.name;
     if (!pvcName) return null;
@@ -155,10 +156,6 @@ export async function getPodMetrics(
             cpu: normalizeCpu(lastTwoWeeksUsage.cpu),
             memory: normalizeMemory(lastTwoWeeksUsage.memory),
           },
-          limits: {
-            cpu: normalizeCpu(resourceDef.resources?.limits?.cpu || 0),
-            memory: normalizeMemory(resourceDef.resources?.limits?.memory || 0),
-          },
           requests: {
             cpu: normalizeCpu(resourceDef.resources?.requests?.cpu || 0),
             memory: normalizeMemory(resourceDef.resources?.requests?.memory || 0),