qontract-reconcile 0.10.1rc1149__py3-none-any.whl → 0.10.1rc1151__py3-none-any.whl

tools/cli_commands/cost_report/util.py

@@ -2,7 +2,13 @@ from collections import defaultdict
 from collections.abc import Callable, Iterable, Mapping, MutableMapping
 from typing import Any
 
+from reconcile.typed_queries.app_interface_vault_settings import (
+    get_app_interface_vault_settings,
+)
 from reconcile.typed_queries.cost_report.app_names import App
+from reconcile.typed_queries.cost_report.settings import get_cost_report_settings
+from reconcile.utils.gql import GqlApi
+from reconcile.utils.secret_reader import create_secret_reader
 from tools.cli_commands.cost_report.model import Report
 
 
@@ -57,3 +63,10 @@ def process_reports(
             report_builder=report_builder,
         )
     return reports
+
+
+def fetch_cost_report_secret(gql_api: GqlApi) -> dict[str, str]:
+    vault_settings = get_app_interface_vault_settings(gql_api.query)
+    secret_reader = create_secret_reader(use_vault=vault_settings.vault)
+    cost_report_settings = get_cost_report_settings(gql_api)
+    return secret_reader.read_all_secret(cost_report_settings.credentials)

tools/cli_commands/cost_report/view.py

@@ -1,10 +1,10 @@
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from decimal import Decimal
 from typing import Any
 
 from pydantic import BaseModel
 
-from tools.cli_commands.cost_report.model import Report
+from tools.cli_commands.cost_report.model import OptimizationReport, Report
 
 LAYOUT = """\
 [TOC]
@@ -15,6 +15,13 @@ LAYOUT = """\
 {cost_breakdown}\
 """
 
+OPTIMIZATION_LAYOUT = """\
+[TOC]
+
+{header}
+{optimizations}\
+"""
+
 AWS_HEADER = """\
 # AWS Cost Report
 """
@@ -23,6 +30,19 @@ OPENSHIFT_HEADER = """\
 # OpenShift Cost Report
 """
 
+OPTIMIZATION_HEADER = """\
+# OpenShift Cost Optimization Report
+
+Report is generated for optimization enabled namespaces
+(`insights_cost_management_optimizations='true'` in namespace `labels`).
+
+In Cost optimizations, recommendations get generated when
+CPU usage is at or above the 60th percentile and
+memory usage is at the 100th percentile.
+
+View details in [Cost Management Optimizations](https://console.redhat.com/openshift/cost-management/optimizations).
+"""
+
 AWS_SUMMARY = """\
 ## Summary
 
@@ -107,6 +127,14 @@ TOTAL_COST = """\
 Total Cost: {total}
 """
 
+OPTIMIZATION = """\
+## {app_name}
+
+```json:table
+{json_table}
+```
+"""
+
 
 class TableField(BaseModel):
     key: str
@@ -146,6 +174,19 @@ class ViewChildAppReport(BaseModel):
     total: Decimal
 
 
+class ViewOptimizationReportItem(BaseModel):
+    namespace: str
+    workload: str
+    current_cpu_limit: str | None
+    current_cpu_request: str | None
+    current_memory_limit: str | None
+    current_memory_request: str | None
+    recommend_cpu_limit: str | None
+    recommend_cpu_request: str | None
+    recommend_memory_limit: str | None
+    recommend_memory_request: str | None
+
+
 def format_cost_value(value: Decimal) -> str:
     return f"${value:,.2f}"
 
@@ -396,3 +437,88 @@ def render_openshift_cost_report(
             item_cost_renderer=render_openshift_workloads_cost,
         ),
     )
+
+
+def render_optimization(
+    report: OptimizationReport,
+) -> str:
+    items = [
+        ViewOptimizationReportItem(
+            namespace=f"{i.cluster}/{i.project}",
+            workload=f"{i.workload_type}/{i.workload}/{i.container}",
+            current_cpu_limit=i.current_cpu_limit,
+            current_cpu_request=i.current_cpu_request,
+            current_memory_limit=i.current_memory_limit,
+            current_memory_request=i.current_memory_request,
+            recommend_cpu_limit=i.recommend_cpu_limit,
+            recommend_cpu_request=i.recommend_cpu_request,
+            recommend_memory_limit=i.recommend_memory_limit,
+            recommend_memory_request=i.recommend_memory_request,
+        )
+        for i in report.items
+    ]
+    json_table = JsonTable(
+        filter=True,
+        items=sorted(items, key=lambda item: (item.namespace, item.workload)),
+        fields=[
+            TableField(key="namespace", label="Namespace", sortable=True),
+            TableField(key="workload", label="Workload", sortable=True),
+            TableField(
+                key="current_cpu_request", label="Current CPU Request", sortable=True
+            ),
+            TableField(
+                key="recommend_cpu_request",
+                label="Recommend CPU Request",
+                sortable=True,
+            ),
+            TableField(
+                key="current_cpu_limit", label="Current CPU Limit", sortable=True
+            ),
+            TableField(
+                key="recommend_cpu_limit", label="Recommend CPU Limit", sortable=True
+            ),
+            TableField(
+                key="current_memory_request",
+                label="Current Memory Request",
+                sortable=True,
+            ),
+            TableField(
+                key="recommend_memory_request",
+                label="Recommend Memory Request",
+                sortable=True,
+            ),
+            TableField(
+                key="current_memory_limit", label="Current Memory Limit", sortable=True
+            ),
+            TableField(
+                key="recommend_memory_limit",
+                label="Recommend Memory Limit",
+                sortable=True,
+            ),
+        ],
+    )
+    return OPTIMIZATION.format(
+        app_name=report.app_name,
+        json_table=json_table.json(indent=2),
+    )
+
+
+def render_optimizations(
+    reports: Iterable[OptimizationReport],
+) -> str:
+    return "\n".join(
+        render_optimization(report=report)
+        for report in sorted(
+            reports,
+            key=lambda item: item.app_name.lower(),
+        )
+    )
+
+
+def render_openshift_cost_optimization_report(
+    reports: Iterable[OptimizationReport],
+) -> str:
+    return OPTIMIZATION_LAYOUT.format(
+        header=OPTIMIZATION_HEADER,
+        optimizations=render_optimizations(reports),
+    )

tools/cli_commands/test/conftest.py

@@ -0,0 +1,332 @@
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from tools.cli_commands.cost_report.response import (
+    OpenShiftCostOptimizationReportResponse,
+    OpenShiftCostOptimizationResponse,
+    RecommendationEngineResponse,
+    RecommendationEnginesResponse,
+    RecommendationResourcesResponse,
+    RecommendationsResponse,
+    RecommendationTermResponse,
+    RecommendationTermsResponse,
+    ResourceConfigResponse,
+    ResourceResponse,
+)
+
+
+@pytest.fixture
+def fx() -> Callable:
+    def _fx(name: str) -> str:
+        return (Path(__file__).parent / "fixtures" / name).read_text()
+
+    return _fx
+
+
+COST_MANAGEMENT_CONSOLE_BASE_URL = (
+    "https://console.redhat.com/openshift/cost-management"
+)
+
+COST_MANAGEMENT_API_HOST = "https://host/"
+
+COST_REPORT_SECRET = {
+    "api_base_url": f"{COST_MANAGEMENT_API_HOST}/v1",
+    "token_url": "token_url",
+    "client_id": "client_id",
+    "client_secret": "client_secret",
+    "scope": "scope",
+    "console_base_url": COST_MANAGEMENT_CONSOLE_BASE_URL,
+}
+
+OPENSHIFT_COST_OPTIMIZATION_RESPONSE = OpenShiftCostOptimizationReportResponse(
+    data=[
+        OpenShiftCostOptimizationResponse(
+            cluster_alias="some-cluster",
+            cluster_uuid="some-cluster-uuid",
+            container="test",
+            id="id-uuid",
+            project="some-project",
+            workload="test-deployment",
+            workload_type="deployment",
+            recommendations=RecommendationsResponse(
+                current=RecommendationResourcesResponse(
+                    limits=ResourceResponse(
+                        cpu=ResourceConfigResponse(amount=4),
+                        memory=ResourceConfigResponse(amount=5, format="Gi"),
+                    ),
+                    requests=ResourceResponse(
+                        cpu=ResourceConfigResponse(amount=1),
+                        memory=ResourceConfigResponse(amount=400, format="Mi"),
+                    ),
+                ),
+                recommendation_terms=RecommendationTermsResponse(
+                    long_term=RecommendationTermResponse(),
+                    medium_term=RecommendationTermResponse(),
+                    short_term=RecommendationTermResponse(
+                        recommendation_engines=RecommendationEnginesResponse(
+                            cost=RecommendationEngineResponse(
+                                config=RecommendationResourcesResponse(
+                                    limits=ResourceResponse(
+                                        cpu=ResourceConfigResponse(amount=5),
+                                        memory=ResourceConfigResponse(
+                                            amount=6, format="Gi"
+                                        ),
+                                    ),
+                                    requests=ResourceResponse(
+                                        cpu=ResourceConfigResponse(amount=3),
+                                        memory=ResourceConfigResponse(
+                                            amount=700, format="Mi"
+                                        ),
+                                    ),
+                                ),
+                                variation=RecommendationResourcesResponse(
+                                    limits=ResourceResponse(
+                                        cpu=ResourceConfigResponse(amount=1),
+                                        memory=ResourceConfigResponse(
+                                            amount=1, format="Gi"
+                                        ),
+                                    ),
+                                    requests=ResourceResponse(
+                                        cpu=ResourceConfigResponse(amount=2),
+                                        memory=ResourceConfigResponse(
+                                            amount=300, format="Mi"
+                                        ),
+                                    ),
+                                ),
+                            ),
+                            performance=RecommendationEngineResponse(
+                                config=RecommendationResourcesResponse(
+                                    limits=ResourceResponse(
+                                        cpu=ResourceConfigResponse(amount=3),
+                                        memory=ResourceConfigResponse(
+                                            amount=6, format="Gi"
+                                        ),
+                                    ),
+                                    requests=ResourceResponse(
+                                        cpu=ResourceConfigResponse(
+                                            amount=600, format="millicores"
+                                        ),
+                                        memory=ResourceConfigResponse(
+                                            amount=700, format="Mi"
+                                        ),
+                                    ),
+                                ),
+                                variation=RecommendationResourcesResponse(
+                                    limits=ResourceResponse(
+                                        cpu=ResourceConfigResponse(amount=-1),
+                                        memory=ResourceConfigResponse(
+                                            amount=1, format="Gi"
+                                        ),
+                                    ),
+                                    requests=ResourceResponse(
+                                        cpu=ResourceConfigResponse(
+                                            amount=-400, format="millicores"
+                                        ),
+                                        memory=ResourceConfigResponse(
+                                            amount=300, format="Mi"
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        )
+                    ),
+                ),
+            ),
+        )
+    ]
+)
+
+OPENSHIFT_COST_OPTIMIZATION_WITH_FUZZY_MATCH_RESPONSE = (
+    OpenShiftCostOptimizationReportResponse(
+        data=[
+            OpenShiftCostOptimizationResponse(
+                cluster_alias="some-cluster",
+                cluster_uuid="some-cluster-uuid",
+                container="test",
+                id="id-uuid",
+                project="some-project",
+                workload="test-deployment",
+                workload_type="deployment",
+                recommendations=RecommendationsResponse(
+                    current=RecommendationResourcesResponse(
+                        limits=ResourceResponse(
+                            cpu=ResourceConfigResponse(amount=4),
+                            memory=ResourceConfigResponse(amount=5, format="Gi"),
+                        ),
+                        requests=ResourceResponse(
+                            cpu=ResourceConfigResponse(amount=1),
+                            memory=ResourceConfigResponse(amount=400, format="Mi"),
+                        ),
+                    ),
+                    recommendation_terms=RecommendationTermsResponse(
+                        long_term=RecommendationTermResponse(),
+                        medium_term=RecommendationTermResponse(),
+                        short_term=RecommendationTermResponse(
+                            recommendation_engines=RecommendationEnginesResponse(
+                                cost=RecommendationEngineResponse(
+                                    config=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=5),
+                                            memory=ResourceConfigResponse(
+                                                amount=6, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=3),
+                                            memory=ResourceConfigResponse(
+                                                amount=700, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                    variation=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=1),
+                                            memory=ResourceConfigResponse(
+                                                amount=1, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=2),
+                                            memory=ResourceConfigResponse(
+                                                amount=300, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                performance=RecommendationEngineResponse(
+                                    config=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=3),
+                                            memory=ResourceConfigResponse(
+                                                amount=6, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(
+                                                amount=600, format="millicores"
+                                            ),
+                                            memory=ResourceConfigResponse(
+                                                amount=700, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                    variation=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=-1),
+                                            memory=ResourceConfigResponse(
+                                                amount=1, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(
+                                                amount=-400, format="millicores"
+                                            ),
+                                            memory=ResourceConfigResponse(
+                                                amount=300, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            )
+                        ),
+                    ),
+                ),
+            ),
+            OpenShiftCostOptimizationResponse(
+                cluster_alias="some-cluster2",
+                cluster_uuid="some-cluster-uuid2",
+                container="test",
+                id="id-uuid",
+                project="some-project2",
+                workload="test-deployment",
+                workload_type="deployment",
+                recommendations=RecommendationsResponse(
+                    current=RecommendationResourcesResponse(
+                        limits=ResourceResponse(
+                            cpu=ResourceConfigResponse(amount=4),
+                            memory=ResourceConfigResponse(amount=5, format="Gi"),
+                        ),
+                        requests=ResourceResponse(
+                            cpu=ResourceConfigResponse(amount=1),
+                            memory=ResourceConfigResponse(amount=400, format="Mi"),
+                        ),
+                    ),
+                    recommendation_terms=RecommendationTermsResponse(
+                        long_term=RecommendationTermResponse(),
+                        medium_term=RecommendationTermResponse(),
+                        short_term=RecommendationTermResponse(
+                            recommendation_engines=RecommendationEnginesResponse(
+                                cost=RecommendationEngineResponse(
+                                    config=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=5),
+                                            memory=ResourceConfigResponse(
+                                                amount=6, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=3),
+                                            memory=ResourceConfigResponse(
+                                                amount=700, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                    variation=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=1),
+                                            memory=ResourceConfigResponse(
+                                                amount=1, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=2),
+                                            memory=ResourceConfigResponse(
+                                                amount=300, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                                performance=RecommendationEngineResponse(
+                                    config=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=3),
+                                            memory=ResourceConfigResponse(
+                                                amount=6, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(
+                                                amount=600, format="millicores"
+                                            ),
+                                            memory=ResourceConfigResponse(
+                                                amount=700, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                    variation=RecommendationResourcesResponse(
+                                        limits=ResourceResponse(
+                                            cpu=ResourceConfigResponse(amount=-1),
+                                            memory=ResourceConfigResponse(
+                                                amount=1, format="Gi"
+                                            ),
+                                        ),
+                                        requests=ResourceResponse(
+                                            cpu=ResourceConfigResponse(
+                                                amount=-400, format="millicores"
+                                            ),
+                                            memory=ResourceConfigResponse(
+                                                amount=300, format="Mi"
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            )
+                        ),
+                    ),
+                ),
+            ),
+        ]
+    )
+)