Dataset generated from https://github.com/prometheus-operator/kube-prometheus/blob/main/manifests/grafana-dashboardDefinitions.yaml

extract.py

import yaml
import json
import re
import ollama

dashboard_file = "manifests/grafana-dashboardDefinitions.yaml"

yaml_data = None

with open(dashboard_file, "r") as f:
    data = f.read()
    yaml_data = yaml.safe_load(data)
    # print(yaml_data)

# find all the "node" with "description" and "targets" key

items = yaml_data["items"]


class PromQueryDiscovery:
    def __init__(self, dashboard_data: dict, root=False, title_prefix=""):
        self.dashboard_data = dashboard_data
        self.queries = []
        self.title_prefix = title_prefix
        if root:
            self.title_prefix = dashboard_data["title"]

    def transform_legend_format(self, template):
        pattern = re.compile(r"\{\{(.*?)\}\}")

        matches = pattern.findall(template)

        if len(matches) == 0:
            return template

        transformed = "by " + " and ".join(matches)

        result = re.sub(r"\{\{(.*?)\}\}", "", template).strip()
        result = f"{transformed} {result if result else ""}"
        return result

    def get_queries(self):
        if isinstance(self.dashboard_data, dict):
            for key, value in self.dashboard_data.items():
                if key == "panels":
                    for panel in value:
                        if "title" in panel and "targets" in panel:
                            for target in panel["targets"]:
                                title = panel["title"]
                                if self.title_prefix != "":
                                    title = f"{self.title_prefix}: {title}"
                                if (
                                    "legendFormat" in target
                                    and target["legendFormat"] != "__auto"
                                ):
                                    # title = f"{title} - {target['legendFormat']}"
                                    title = f"{title} {self.transform_legend_format(target['legendFormat'])}"
                                if "description" in target:
                                    title = f"{target['description']}: {title}"

                                is_table = target.get("format", "") == "table"
                                if not is_table:
                                    self.queries.append(
                                        (title, target["expr"]),
                                    )
                else:
                    self.queries.extend(
                        PromQueryDiscovery(
                            value, title_prefix=self.title_prefix
                        ).get_queries()
                    )
            return self.queries
        if isinstance(self.dashboard_data, list):
            for item in self.dashboard_data:
                self.queries.extend(
                    PromQueryDiscovery(
                        item, title_prefix=self.title_prefix
                    ).get_queries()
                )
            return self.queries
        return self.queries


dataset = []
for item in items:
    kind = item["kind"]
    if kind == "ConfigMap":
        data = item["data"]
        for dashboard_filename, value in data.items():
            print(dashboard_filename)
            dashboard_data = json.loads(value)
            prom_query_discovery = PromQueryDiscovery(dashboard_data, root=True)
            dataset.extend(prom_query_discovery.get_queries())

# mistral_endpoint = "http://localhost:11434/api/generate"

for i, query in enumerate(dataset):
    title, expr = query
    resp = ollama.chat(
        model="mistral",
        messages=[
            {
                "role": "user",
                "content": f'turn the following sentence into a one-sentence short question: "{title}"',
            },
        ],
    )

    new_title = resp["message"]["content"].strip()
    # remove prefix and suffix "
    new_title = re.sub(r'^"|"$', "", new_title)
    dataset[i] = (new_title, expr)

## Save the dataset into jsonl
with open("promql.jsonl", "w") as f:
    for title, expr in dataset:
        promql = f"[PROMQL] {expr} [/PROMQL]"
        f.write(json.dumps({
            "question": title,
            "context": "",
            "answer": promql,
        }) + "\n")

promql.jsonl

{"question": "What are the alerts by instance in Alertmanager?", "context": "", "answer": "[PROMQL] sum(alertmanager_alerts{namespace=~\"$namespace\",service=~\"$service\"}) by (namespace,service,instance) [/PROMQL]"}
{"question": "What is the alerts receive rate by instance in the Alertmanager overview?", "context": "", "answer": "[PROMQL] sum(rate(alertmanager_alerts_received_total{namespace=~\"$namespace\",service=~\"$service\"}[$__rate_interval])) by (namespace,service,instance) [/PROMQL]"}
{"question": "What is the current alerts receive rate per instance in Alertmanager, and is it invalid?", "context": "", "answer": "[PROMQL] sum(rate(alertmanager_alerts_invalid_total{namespace=~\"$namespace\",service=~\"$service\"}[$__rate_interval])) by (namespace,service,instance) [/PROMQL]"}
{"question": "What is the notifications send rate by instance total for Alertmanager: Integration?", "context": "", "answer": "[PROMQL] sum(rate(alertmanager_notifications_total{namespace=~\"$namespace\",service=~\"$service\", integration=\"$integration\"}[$__rate_interval])) by (integration,namespace,service,instance) [/PROMQL]"}
{"question": "What is the Notifications Send Rate by instance for the integration where it has failed in Alertmanager Overview?", "context": "", "answer": "[PROMQL] sum(rate(alertmanager_notifications_failed_total{namespace=~\"$namespace\",service=~\"$service\", integration=\"$integration\"}[$__rate_interval])) by (integration,namespace,service,instance) [/PROMQL]"}
{"question": "What is the 99th Percentile Notification Duration for each instance in Alertmanager's overview regarding integration?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99,\n  sum(rate(alertmanager_notification_latency_seconds_bucket{namespace=~\"$namespace\",service=~\"$service\", integration=\"$integration\"}[$__rate_interval])) by (le,namespace,service,instance)\n) \n [/PROMQL]"}
{"question": "What is the median Notification Duration by instance in Alertmanager Overview for the given integration?", "context": "", "answer": "[PROMQL] histogram_quantile(0.50,\n  sum(rate(alertmanager_notification_latency_seconds_bucket{namespace=~\"$namespace\",service=~\"$service\", integration=\"$integration\"}[$__rate_interval])) by (le,namespace,service,instance)\n) \n [/PROMQL]"}
{"question": "What is the average notification duration by instance in Alertmanager - Overview for the integration?", "context": "", "answer": "[PROMQL] sum(rate(alertmanager_notification_latency_seconds_sum{namespace=~\"$namespace\",service=~\"$service\", integration=\"$integration\"}[$__rate_interval])) by (namespace,service,instance)\n/\nsum(rate(alertmanager_notification_latency_seconds_count{namespace=~\"$namespace\",service=~\"$service\", integration=\"$integration\"}[$__rate_interval])) by (namespace,service,instance)\n [/PROMQL]"}
{"question": "What is the availability percentage of the Kubernetes API server over the past 30 days, ensuring it exceeds 99.00%?", "context": "", "answer": "[PROMQL] apiserver_request:availability30d{verb=\"all\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the ErrorBudget percentage of the Kubernetes API server for the last 30 days, and does it exceed 99.000%?", "context": "", "answer": "[PROMQL] 100 * (apiserver_request:availability30d{verb=\"all\", cluster=\"$cluster\"} - 0.990000) [/PROMQL]"}
{"question": "What is the read availability of the Kubernetes API server for the past 30 days?", "context": "", "answer": "[PROMQL] apiserver_request:availability30d{verb=\"read\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the read of SLI - Requests by code in the Kubernetes API server?", "context": "", "answer": "[PROMQL] sum by (code) (code_resource:apiserver_request_total:rate5m{verb=\"read\", cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What are the errors for SLI (Service Level Indicator) by resource in the Kubernetes API server?", "context": "", "answer": "[PROMQL] sum by (resource) (code_resource:apiserver_request_total:rate5m{verb=\"read\",code=~\"5..\", cluster=\"$cluster\"}) / sum by (resource) (code_resource:apiserver_request_total:rate5m{verb=\"read\", cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the duration of an SLI (Service Level Indicator) read operation for a specific resource in the Kubernetes API server?", "context": "", "answer": "[PROMQL] cluster_quantile:apiserver_request_sli_duration_seconds:histogram_quantile{verb=\"read\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the 30-day write availability of the Kubernetes API server?", "context": "", "answer": "[PROMQL] apiserver_request:availability30d{verb=\"write\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the process for writing an SLI (Service Level Indicator) for Kubernetes/API server regarding Request by code?", "context": "", "answer": "[PROMQL] sum by (code) (code_resource:apiserver_request_total:rate5m{verb=\"write\", cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the SLI (Service Level Indicator) for errors by resource in the Kubernetes API server?", "context": "", "answer": "[PROMQL] sum by (resource) (code_resource:apiserver_request_total:rate5m{verb=\"write\",code=~\"5..\", cluster=\"$cluster\"}) / sum by (resource) (code_resource:apiserver_request_total:rate5m{verb=\"write\", cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the procedure for writing a Service Level Indicator (SLI) that measures duration by resource in the Kubernetes API server?", "context": "", "answer": "[PROMQL] cluster_quantile:apiserver_request_sli_duration_seconds:histogram_quantile{verb=\"write\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the work queue add rate for each instance and name in the Kubernetes/API server?", "context": "", "answer": "[PROMQL] sum(rate(workqueue_adds_total{job=\"apiserver\", instance=~\"$instance\", cluster=\"$cluster\"}[$__rate_interval])) by (instance, name) [/PROMQL]"}
{"question": "What is the work queue depth by instance and name for the Kubernetes API server?", "context": "", "answer": "[PROMQL] sum(rate(workqueue_depth{job=\"apiserver\", instance=~\"$instance\", cluster=\"$cluster\"}[$__rate_interval])) by (instance, name) [/PROMQL]"}
{"question": "What is the work queue latency, by instance and name, in the Kubernetes/API server?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(workqueue_queue_duration_seconds_bucket{job=\"apiserver\", instance=~\"$instance\", cluster=\"$cluster\"}[$__rate_interval])) by (instance, name, le)) [/PROMQL]"}
{"question": "What is the memory usage for each instance in the Kubernetes API server?", "context": "", "answer": "[PROMQL] process_resident_memory_bytes{job=\"apiserver\",instance=~\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the CPU usage by instance in the Kubernetes API server?", "context": "", "answer": "[PROMQL] rate(process_cpu_seconds_total{job=\"apiserver\",instance=~\"$instance\", cluster=\"$cluster\"}[$__rate_interval]) [/PROMQL]"}
{"question": "Are Goroutines in Kubernetes API server instance-specific?", "context": "", "answer": "[PROMQL] go_goroutines{job=\"apiserver\",instance=~\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the current rate of bytes received in the Kubernetes cluster regarding networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the current rate of bytes transmitted in the Kubernetes cluster's networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the average rate of bytes received in a Kubernetes cluster regarding networking?", "context": "", "answer": "[PROMQL] avg by (namespace) (rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the average rate of bytes transmitted in a Kubernetes cluster regarding networking?", "context": "", "answer": "[PROMQL] avg by (namespace) (rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the receive bandwidth for the Kubernetes cluster in terms of networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the bandwidth transmission for the Kubernetes cluster networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of received packets in a Kubernetes cluster regarding networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_receive_packets_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of transmitted packets in the Kubernetes cluster network?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_transmit_packets_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of received packets dropped in the Kubernetes cluster regarding networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_receive_packets_dropped_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of transmitted packets dropped in the Kubernetes cluster's networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_transmit_packets_dropped_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of TCP retransmits out of all sent segments in the Kubernetes cluster regarding networking?", "context": "", "answer": "[PROMQL] sum by (instance) (rate(node_netstat_Tcp_RetransSegs{cluster=\"$cluster\"}[$__rate_interval]) / rate(node_netstat_Tcp_OutSegs{cluster=\"$cluster\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of TCP SYN Retransmits out of all retransmits in the Kubernetes cluster networking?", "context": "", "answer": "[PROMQL] sum by (instance) (rate(node_netstat_TcpExt_TCPSynRetrans{cluster=\"$cluster\"}[$__rate_interval]) / rate(node_netstat_Tcp_RetransSegs{cluster=\"$cluster\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "Is Kubernetes Controller Manager currently running?", "context": "", "answer": "[PROMQL] sum(up{cluster=\"$cluster\", job=\"kube-controller-manager\"}) [/PROMQL]"}
{"question": "What is the Work Queue Add Rate for Kubernetes Controller Manager, cluster by cluster and instance by instance, sorted by its name?", "context": "", "answer": "[PROMQL] sum(rate(workqueue_adds_total{cluster=\"$cluster\", job=\"kube-controller-manager\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, name) [/PROMQL]"}
{"question": "What is the work queue depth for Kubernetes Controller Manager, segmented by cluster, instance, and name?", "context": "", "answer": "[PROMQL] sum(rate(workqueue_depth{cluster=\"$cluster\", job=\"kube-controller-manager\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, name) [/PROMQL]"}
{"question": "What is the work queue latency for Kubernetes Controller Manager, segmented by cluster, instance, and name?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(workqueue_queue_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-controller-manager\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, name, le)) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for the Kubernetes Controller Manager (2xx)?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{job=\"kube-controller-manager\", instance=~\"$instance\",code=~\"2..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for Kubernetes Controller Manager?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{job=\"kube-controller-manager\", instance=~\"$instance\",code=~\"3..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for Kubernetes Controller Manager (4xx)?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{job=\"kube-controller-manager\", instance=~\"$instance\",code=~\"4..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kubernetes Controller Manager's Kube API Request Rate for 5xx errors?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{job=\"kube-controller-manager\", instance=~\"$instance\",code=~\"5..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the 99th quantile post request latency, grouped by verb and URL, in Kubernetes Controller Manager?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-controller-manager\", instance=~\"$instance\", verb=\"POST\"}[$__rate_interval])) by (verb, url, le)) [/PROMQL]"}
{"question": "What is the 99th quantile request latency for each verb and URL in Kubernetes Controller Manager?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-controller-manager\", instance=~\"$instance\", verb=\"GET\"}[$__rate_interval])) by (verb, url, le)) [/PROMQL]"}
{"question": "What is the memory usage of each Kubernetes Controller Manager instance?", "context": "", "answer": "[PROMQL] process_resident_memory_bytes{cluster=\"$cluster\", job=\"kube-controller-manager\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the CPU usage by the Kubernetes Controller Manager instance?", "context": "", "answer": "[PROMQL] rate(process_cpu_seconds_total{cluster=\"$cluster\", job=\"kube-controller-manager\",instance=~\"$instance\"}[$__rate_interval]) [/PROMQL]"}
{"question": "Are Goroutines used per instance in Kubernetes's Controller Manager?", "context": "", "answer": "[PROMQL] go_goroutines{cluster=\"$cluster\", job=\"kube-controller-manager\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the status of Grafana Overview, specifically regarding Firing Alerts?", "context": "", "answer": "[PROMQL] grafana_alerting_result_total{job=~\"$job\", instance=~\"$instance\", state=\"alerting\"} [/PROMQL]"}
{"question": "What is the Grafana Overview about, specifically?\" (Assuming you're interested in knowing the purpose or content of the dashboards.)", "context": "", "answer": "[PROMQL] sum(grafana_stat_totals_dashboard{job=~\"$job\", instance=~\"$instance\"}) [/PROMQL]"}
{"question": "What is the build information for Grafana Overview?", "context": "", "answer": "[PROMQL] grafana_build_info{job=~\"$job\", instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the RPS (Requests Per Second) breakdown by status_code in Grafana Overview?", "context": "", "answer": "[PROMQL] sum by (status_code) (irate(grafana_http_request_duration_seconds_count{job=~\"$job\", instance=~\"$instance\"}[1m]))  [/PROMQL]"}
{"question": "What is the 99th percentile request latency in Grafana Overview?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(irate(grafana_http_request_duration_seconds_bucket{instance=~\"$instance\", job=~\"$job\"}[$__rate_interval])) by (le)) * 1 [/PROMQL]"}
{"question": "What is the 50th percentile request latency in Grafana Overview?", "context": "", "answer": "[PROMQL] histogram_quantile(0.50, sum(irate(grafana_http_request_duration_seconds_bucket{instance=~\"$instance\", job=~\"$job\"}[$__rate_interval])) by (le)) * 1 [/PROMQL]"}
{"question": "What is the request latency average in Grafana Overview?", "context": "", "answer": "[PROMQL] sum(irate(grafana_http_request_duration_seconds_sum{instance=~\"$instance\", job=~\"$job\"}[$__rate_interval])) * 1 / sum(irate(grafana_http_request_duration_seconds_count{instance=~\"$instance\", job=~\"$job\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the CPU utilization of the Kubernetes cluster regarding compute resources?", "context": "", "answer": "[PROMQL] cluster:node_cpu:ratio_rate5m{cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the CPU Request Commitment for the Kubernetes Cluster regarding Compute Resources?", "context": "", "answer": "[PROMQL] sum(namespace_cpu:kube_pod_container_resource_requests:sum{cluster=\"$cluster\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\",resource=\"cpu\",cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the CPU Limit Commitment for the Kubernetes Cluster in terms of Compute Resources?", "context": "", "answer": "[PROMQL] sum(namespace_cpu:kube_pod_container_resource_limits:sum{cluster=\"$cluster\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\",resource=\"cpu\",cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the memory utilization for the Kubernetes cluster in terms of compute resources?", "context": "", "answer": "[PROMQL] 1 - sum(:node_memory_MemAvailable_bytes:sum{cluster=\"$cluster\"}) / sum(node_memory_MemTotal_bytes{job=\"node-exporter\",cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the Memory Requests Commitment for the Kubernetes Cluster in terms of Compute Resources?", "context": "", "answer": "[PROMQL] sum(namespace_memory:kube_pod_container_resource_requests:sum{cluster=\"$cluster\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\",resource=\"memory\",cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the memory limits commitment for the Kubernetes cluster's compute resources?", "context": "", "answer": "[PROMQL] sum(namespace_memory:kube_pod_container_resource_limits:sum{cluster=\"$cluster\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\",resource=\"memory\",cluster=\"$cluster\"}) [/PROMQL]"}
{"question": "What is the CPU usage of the Kubernetes cluster regarding compute resources?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\"}) by (namespace) [/PROMQL]"}
{"question": "What is the memory for the Kubernetes cluster compute resources?", "context": "", "answer": "[PROMQL] sum(container_memory_rss{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", container!=\"\"}) by (namespace) [/PROMQL]"}
{"question": "What is the bandwidth received by the Kubernetes cluster in terms of compute resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the bandwidth transmission for the Kubernetes Cluster regarding compute resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the average container bandwidth (received) per namespace in this Kubernetes cluster?", "context": "", "answer": "[PROMQL] avg(irate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the average container bandwidth (transmitted) for each namespace within the Kubernetes cluster in terms of compute resources?", "context": "", "answer": "[PROMQL] avg(irate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the rate of received packets in the Kubernetes cluster regarding compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_receive_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the rate of transmitted packets in the Kubernetes cluster regarding compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_transmit_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the rate of dropped packets received in the Kubernetes cluster regarding compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_receive_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What is the rate of transmitted packets dropped in the Kubernetes cluster regarding compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_transmit_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=~\".+\"}[$__rate_interval])) by (namespace) [/PROMQL]"}
{"question": "What are the IOPS for Reads and Writes in the Kubernetes Cluster regarding Compute Resources?", "context": "", "answer": "[PROMQL] ceil(sum by(namespace) (rate(container_fs_reads_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", cluster=\"$cluster\", namespace!=\"\"}[$__rate_interval]) + rate(container_fs_writes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", cluster=\"$cluster\", namespace!=\"\"}[$__rate_interval]))) [/PROMQL]"}
{"question": "What is the ThroughPut (Read+Write) of Kubernetes Cluster regarding Compute Resources?", "context": "", "answer": "[PROMQL] sum by(namespace) (rate(container_fs_reads_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", cluster=\"$cluster\", namespace!=\"\"}[$__rate_interval]) + rate(container_fs_writes_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", cluster=\"$cluster\", namespace!=\"\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the CPU utilization for multi-cluster Kubernetes compute resources?", "context": "", "answer": "[PROMQL] cluster:node_cpu:ratio_rate5m [/PROMQL]"}
{"question": "What is the CPU Request Commitment for Multi-Cluster in Kubernetes Compute Resources?", "context": "", "answer": "[PROMQL] sum(kube_pod_container_resource_requests{job=\"kube-state-metrics\", resource=\"cpu\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\", resource=\"cpu\"}) [/PROMQL]"}
{"question": "What are the CPU limits commitment for multi-cluster in Kubernetes regarding compute resources?", "context": "", "answer": "[PROMQL] sum(kube_pod_container_resource_limits{job=\"kube-state-metrics\", resource=\"cpu\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\", resource=\"cpu\"}) [/PROMQL]"}
{"question": "What is the memory utilization in a multi-cluster Kubernetes environment regarding compute resources?", "context": "", "answer": "[PROMQL] 1 - sum(:node_memory_MemAvailable_bytes:sum) / sum(node_memory_MemTotal_bytes{job=\"node-exporter\"}) [/PROMQL]"}
{"question": "What is the memory request commitment for multi-cluster in Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum(kube_pod_container_resource_requests{job=\"kube-state-metrics\", resource=\"memory\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\", resource=\"memory\"}) [/PROMQL]"}
{"question": "What are the memory limits commitment for multi-cluster in Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum(kube_pod_container_resource_limits{job=\"kube-state-metrics\", resource=\"memory\"}) / sum(kube_node_status_allocatable{job=\"kube-state-metrics\", resource=\"memory\"}) [/PROMQL]"}
{"question": "What is the CPU usage in a multi-cluster Kubernetes environment for compute resources?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate) by (cluster) [/PROMQL]"}
{"question": "What is the memory usage (without cache) for multi-cluster Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum(container_memory_rss{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\"}) by (cluster) [/PROMQL]"}
{"question": "What is the CPU utilization from requests for Pods within a Namespace in Kubernetes regarding compute resources?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\", namespace=\"$namespace\"}) / sum(kube_pod_container_resource_requests{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", resource=\"cpu\"}) [/PROMQL]"}
{"question": "What is the CPU utilization (from limits) of Pods in a Namespace within Kubernetes' Compute Resources?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\", namespace=\"$namespace\"}) / sum(kube_pod_container_resource_limits{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", resource=\"cpu\"}) [/PROMQL]"}
{"question": "What is the memory utilization (from requests) of Pods within a Namespace for compute resources in Kubernetes?", "context": "", "answer": "[PROMQL] sum(container_memory_working_set_bytes{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\",container!=\"\", image!=\"\"}) / sum(kube_pod_container_resource_requests{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", resource=\"memory\"}) [/PROMQL]"}
{"question": "What is the memory utilization (from limits) of Pods within a Namespace in Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] sum(container_memory_working_set_bytes{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\",container!=\"\", image!=\"\"}) / sum(kube_pod_container_resource_limits{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", resource=\"memory\"}) [/PROMQL]"}
{"question": "What is the CPU usage of Pods in the Kubernetes Compute Resources under Namespace?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\", namespace=\"$namespace\"}) by (pod) [/PROMQL]"}
{"question": "What is the CPU usage quota - requests for Pods within a Namespace in Kubernetes regarding Compute Resources?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"requests.cpu\"}) [/PROMQL]"}
{"question": "What is the CPU usage quota for the Pods within a Namespace in Kubernetes regarding compute resources?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"limits.cpu\"}) [/PROMQL]"}
{"question": "What is the memory usage (without cache) of Pods within a Namespace in Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] sum(container_memory_working_set_bytes{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", container!=\"\", image!=\"\"}) by (pod) [/PROMQL]"}
{"question": "What is the memory usage (without cache) quota for requests in terms of Kubernetes namespace (Pods), under compute resources?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"requests.memory\"}) [/PROMQL]"}
{"question": "What is the without-cache memory usage quota for namespace (pods) under compute resources in Kubernetes regarding their limits?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"limits.memory\"}) [/PROMQL]"}
{"question": "What is the receive bandwidth for Pods within a Namespace in Kubernetes regarding Compute Resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the transmit bandwidth for Pods within a Namespace in Kubernetes regarding compute resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of received packets in the Namespace (Pods) of Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_receive_packets_total{cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of transmitted packets in the namespace (pods) of Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_transmit_packets_total{cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of dropped packets received in Namespace (Pods) for Kubernetes Compute Resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_receive_packets_dropped_total{cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of transmitted packets dropped in the Kubernetes Namespace (Pods) regarding compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_transmit_packets_dropped_total{cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What are the IOPS for reads and writes in the Pods within a Kubernetes Namespace regarding Compute Resources?", "context": "", "answer": "[PROMQL] ceil(sum by(pod) (rate(container_fs_reads_total{container!=\"\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval]) + rate(container_fs_writes_total{container!=\"\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval]))) [/PROMQL]"}
{"question": "What is the ThroughPut (read + write) of Pods in a Namespace within Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] sum by(pod) (rate(container_fs_reads_bytes_total{container!=\"\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval]) + rate(container_fs_writes_bytes_total{container!=\"\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the maximum CPU usage capacity for Pods in a Kubernetes Node?", "context": "", "answer": "[PROMQL] sum(kube_node_status_capacity{cluster=\"$cluster\", node=~\"$node\", resource=\"cpu\"}) [/PROMQL]"}
{"question": "What is the CPU usage of each pod in the Kubernetes Node?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\", node=~\"$node\"}) by (pod) [/PROMQL]"}
{"question": "What is the maximum memory usage (without cache) capacity of the Pods in a Kubernetes Node regarding compute resources?", "context": "", "answer": "[PROMQL] sum(kube_node_status_capacity{cluster=\"$cluster\", node=~\"$node\", resource=\"memory\"}) [/PROMQL]"}
{"question": "What is the memory usage (without cache) of each pod in a Kubernetes compute resource node?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_memory_working_set_bytes{cluster=\"$cluster\", node=~\"$node\", container!=\"\"}) by (pod) [/PROMQL]"}
{"question": "What is the CPU usage of the Pod in Kubernetes regarding Compute Resources?", "context": "", "answer": "[PROMQL] sum(node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{namespace=\"$namespace\", pod=\"$pod\", cluster=\"$cluster\", container!=\"\"}) by (container) [/PROMQL]"}
{"question": "What is the CPU usage request for the Kubernetes pod in compute resources?", "context": "", "answer": "[PROMQL] sum(\n    kube_pod_container_resource_requests{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\", resource=\"cpu\"}\n)\n [/PROMQL]"}
{"question": "What are the CPU usage limits for Pods in Kubernetes Compute Resources?", "context": "", "answer": "[PROMQL] sum(\n    kube_pod_container_resource_limits{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\", resource=\"cpu\"}\n)\n [/PROMQL]"}
{"question": "What is the CPU throttling for the Pod in Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum(increase(container_cpu_cfs_throttled_periods_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", namespace=\"$namespace\", pod=\"$pod\", container!=\"\", cluster=\"$cluster\"}[$__rate_interval])) by (container) /sum(increase(container_cpu_cfs_periods_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", namespace=\"$namespace\", pod=\"$pod\", container!=\"\", cluster=\"$cluster\"}[$__rate_interval])) by (container) [/PROMQL]"}
{"question": "What is the memory usage of Kubernetes pod in terms of compute resources (WSS)?", "context": "", "answer": "[PROMQL] sum(container_memory_working_set_bytes{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\", container!=\"\", image!=\"\"}) by (container) [/PROMQL]"}
{"question": "What is the memory usage request for the Pod in Kubernetes' compute resources?", "context": "", "answer": "[PROMQL] sum(\n    kube_pod_container_resource_requests{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\", resource=\"memory\"}\n)\n [/PROMQL]"}
{"question": "What is the memory usage limit for Kubernetes pod compute resources (Working Set Size - WSS)?", "context": "", "answer": "[PROMQL] sum(\n    kube_pod_container_resource_limits{job=\"kube-state-metrics\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\", resource=\"memory\"}\n)\n [/PROMQL]"}
{"question": "What is the receive bandwidth for a Kubernetes Pod in terms of compute resources?", "context": "", "answer": "[PROMQL] sum(irate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the transmitted bandwidth of a Kubernetes Pod regarding Compute Resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate at which packets are received in a Kubernetes Pod regarding compute resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of transmitted packets per Kubernetes Pod regarding compute resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of dropped packets received in Kubernetes Compute Resources (Pod)?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of transmitted packets dropped in a Kubernetes Pod regarding Compute Resources?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What are the IOPS for reads in the Kubernetes Pod regarding compute resources?", "context": "", "answer": "[PROMQL] ceil(sum by(pod) (rate(container_fs_reads_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval]))) [/PROMQL]"}
{"question": "What are the IOPS (Pod) Writes for Kubernetes Compute Resources under Pod?", "context": "", "answer": "[PROMQL] ceil(sum by(pod) (rate(container_fs_writes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", container!=\"\", cluster=\"$cluster\",namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval]))) [/PROMQL]"}
{"question": "What is the ThroughPut of reads in a Kubernetes pod regarding compute resources?", "context": "", "answer": "[PROMQL] sum by(pod) (rate(container_fs_reads_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the ThroughPut of writes for a Kubernetes pod regarding compute resources?", "context": "", "answer": "[PROMQL] sum by(pod) (rate(container_fs_writes_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What are the IOPS for Kubernetes' compute resources, specifically for the containers within a pod?", "context": "", "answer": "[PROMQL] ceil(sum by(container) (rate(container_fs_reads_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\"}[$__rate_interval]) + rate(container_fs_writes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\"}[$__rate_interval]))) [/PROMQL]"}
{"question": "What is the ThroughPut for Pod containers in Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum by(container) (rate(container_fs_reads_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\"}[$__rate_interval]) + rate(container_fs_writes_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", container!=\"\", cluster=\"$cluster\", namespace=\"$namespace\", pod=\"$pod\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the CPU usage of the workload in Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum(\n    node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\", namespace=\"$namespace\"}\n  * on(namespace,pod)\n    group_left(workload, workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=\"$workload\", workload_type=~\"$type\"}\n) by (pod)\n [/PROMQL]"}
{"question": "What is the memory usage of the workload in Kubernetes compute resources?", "context": "", "answer": "[PROMQL] sum(\n    container_memory_working_set_bytes{cluster=\"$cluster\", namespace=\"$namespace\", container!=\"\", image!=\"\"}\n  * on(namespace,pod)\n    group_left(workload, workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=\"$workload\", workload_type=~\"$type\"}\n) by (pod)\n [/PROMQL]"}
{"question": "What is the bandwidth received by the workload in Kubernetes under compute resources?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the bandwidth transmission for Kubernetes workloads in terms of compute resources?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the average container bandwidth, received per pod, for Kubernetes in terms of compute resources and workload?", "context": "", "answer": "[PROMQL] (avg(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the average container bandwidth by pod, regarding Kubernetes compute resources and workload?", "context": "", "answer": "[PROMQL] (avg(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate of received packets for Kubernetes Compute Resources workload?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_receive_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate of transmitted packets for Kubernetes' compute resources workload?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_transmit_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate of dropped packets in Kubernetes' compute resources for workloads?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_receive_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate at which packets are dropped in Kubernetes' compute resources while handling workloads?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_transmit_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the CPU usage of each workload type within the given namespace in Kubernetes?", "context": "", "answer": "[PROMQL] sum(\n  node_namespace_pod_container:container_cpu_usage_seconds_total:sum_irate{cluster=\"$cluster\", namespace=\"$namespace\"}\n* on(namespace,pod)\n  group_left(workload, workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload_type=~\"$type\"}\n) by (workload, workload_type)\n [/PROMQL]"}
{"question": "What is the CPU usage quota for requests in the workloads' namespace of Kubernetes in terms of compute resources?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"requests.cpu\"}) [/PROMQL]"}
{"question": "What is the CPU usage quota limit for workloads in a namespace within Kubernetes and Compute Resources?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"limits.cpu\"}) [/PROMQL]"}
{"question": "What is the memory usage by workload and workload type in Kubernetes compute resources within a Namespace?", "context": "", "answer": "[PROMQL] sum(\n    container_memory_working_set_bytes{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\", container!=\"\", image!=\"\"}\n  * on(namespace,pod)\n    group_left(workload, workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload_type=~\"$type\"}\n) by (workload, workload_type)\n [/PROMQL]"}
{"question": "What is the memory usage quota for requests in Kubernetes Compute Resources under Namespace (Workloads)?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"requests.memory\"}) [/PROMQL]"}
{"question": "What is the memory usage quota for Kubernetes workloads in terms of compute resources within Namespaces in terms of limits?", "context": "", "answer": "[PROMQL] scalar(kube_resourcequota{cluster=\"$cluster\", namespace=\"$namespace\", type=\"hard\",resource=\"limits.memory\"}) [/PROMQL]"}
{"question": "What is the bandwidth received by workloads within a namespace in Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the transmitted bandwidth for Kubernetes Compute Resources within a Namespace (Workloads)?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the average container bandwidth (received) for each workload in Kubernetes namespace (Compute Resources)?", "context": "", "answer": "[PROMQL] (avg(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the average container bandwidth, transmitted, by workload in Kubernetes compute resources within a Namespace?", "context": "", "answer": "[PROMQL] (avg(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of received packets in the Namespace (Workloads) for Kubernetes Compute Resources?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_receive_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of transmitted packets in the namespace (workloads) of Kubernetes for compute resources?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_transmit_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of dropped packets received in the Kubernetes Namespace for Compute Resources (Workloads)?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_receive_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of transmitted packets dropped in the compute resources namespace (workloads) of Kubernetes?", "context": "", "answer": "[PROMQL] (sum(rate(container_network_transmit_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\", namespace=\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\", namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "Is Kubernetes/Kubelet about running Kubelets?", "context": "", "answer": "[PROMQL] sum(kubelet_node_name{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\"}) [/PROMQL]"}
{"question": "Is Kubernetes/Kubelet currently running any Pods?", "context": "", "answer": "[PROMQL] sum(kubelet_running_pods{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}) [/PROMQL]"}
{"question": "Are you responsible for running containers in Kubernetes or Kubelet?", "context": "", "answer": "[PROMQL] sum(kubelet_running_containers{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}) [/PROMQL]"}
{"question": "What is the actual count of volumes in Kubernetes or Kubelet?", "context": "", "answer": "[PROMQL] sum(volume_manager_total_volumes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\", state=\"actual_state_of_world\"}) [/PROMQL]"}
{"question": "What is the desired volume count for Kubernetes or Kubelet?", "context": "", "answer": "[PROMQL] sum(volume_manager_total_volumes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\",state=\"desired_state_of_world\"}) [/PROMQL]"}
{"question": "What is the Config Error Count for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_node_config_error{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Operation Rate by instance and operation_type for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_runtime_operations_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (operation_type, instance) [/PROMQL]"}
{"question": "What is the Operation Error Rate by instance and operation_type for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_runtime_operations_errors_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_type) [/PROMQL]"}
{"question": "What is the 99th quantile of operation duration for each instance and operation_type in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubelet_runtime_operations_duration_seconds_bucket{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_type, le)) [/PROMQL]"}
{"question": "What is the Pod Start Rate per instance pod for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_pod_start_duration_seconds_count{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance) [/PROMQL]"}
{"question": "What is the Pod Start Rate by instance worker in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_pod_worker_duration_seconds_count{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance) [/PROMQL]"}
{"question": "What is the Pod Start Duration by instance for Kubernetes/Kubelet Pod?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubelet_pod_start_duration_seconds_bucket{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, le)) [/PROMQL]"}
{"question": "What is the Pod Start Duration by instance worker in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubelet_pod_worker_duration_seconds_bucket{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, le)) [/PROMQL]"}
{"question": "What is the Storage Operation Rate for each instance, operation_name, and volume_plugin in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(storage_operation_duration_seconds_count{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_name, volume_plugin) [/PROMQL]"}
{"question": "What is the Storage Operation Error Rate for each instance, operation_name, and volume_plugin in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(storage_operation_errors_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_name, volume_plugin) [/PROMQL]"}
{"question": "What is the 99th quantile of storage operation duration, grouped by instance, operation_name, and volume_plugin, for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(storage_operation_duration_seconds_bucket{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_name, volume_plugin, le)) [/PROMQL]"}
{"question": "What is the cgroup manager operation rate by operation_type for Kubernetes or Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_cgroup_manager_duration_seconds_count{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_type) [/PROMQL]"}
{"question": "What is the 99th quantile of cgroup management for each instance and operation type in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubelet_cgroup_manager_duration_seconds_bucket{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}[$__rate_interval])) by (instance, operation_type, le)) [/PROMQL]"}
{"question": "What is the PLEG relist rate per instance in Kubernetes (Kubelet)?", "context": "", "answer": "[PROMQL] sum(rate(kubelet_pleg_relist_duration_seconds_count{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}[$__rate_interval])) by (instance) [/PROMQL]"}
{"question": "What is the PLEG relist interval in Kubernetes or Kubelet by instance?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubelet_pleg_relist_interval_seconds_bucket{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, le)) [/PROMQL]"}
{"question": "What is the PLEG relist duration for Kubernetes/Kubelet instances?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubelet_pleg_relist_duration_seconds_bucket{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval])) by (instance, le)) [/PROMQL]"}
{"question": "What is the RPC rate for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\",code=~\"2..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the RPC rate for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\",code=~\"3..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the current RPC rate for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\",code=~\"4..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the RPC rate for Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\",code=~\"5..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the 99th quantile request duration for each instance, verb, and URL in Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\", instance=~\"$instance\"}[$__rate_interval])) by (instance, verb, url, le)) [/PROMQL]"}
{"question": "What is the memory usage of an instance managed by Kubernetes (Kubelet)?", "context": "", "answer": "[PROMQL] process_resident_memory_bytes{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the CPU usage of the instance managed by Kubernetes/Kubelet?", "context": "", "answer": "[PROMQL] rate(process_cpu_seconds_total{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"}[$__rate_interval]) [/PROMQL]"}
{"question": "Are Goroutines used per instance in Kubernetes or Kubelet?", "context": "", "answer": "[PROMQL] go_goroutines{cluster=\"$cluster\",job=\"kubelet\", metrics_path=\"/metrics\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the current rate of bytes received for Pods within a Kubernetes Namespace regarding networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the current rate of bytes transmitted for Pods within a Namespace in Kubernetes networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the receive bandwidth for Kubernetes Pods within a Namespace regarding Networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) by (pod) [/PROMQL]"}
{"question": "What is the transmitted bandwidth in Kubernetes Networking, specifically for Pods within a Namespace?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) by (pod) [/PROMQL]"}
{"question": "What is the rate of received packets for Pods within a Kubernetes Namespace related to Networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_packets_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) by (pod) [/PROMQL]"}
{"question": "What is the rate of transmitted packets within a Kubernetes Namespace ( Pods ) regarding networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_packets_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) by (pod) [/PROMQL]"}
{"question": "What is the rate of received packets dropped in the Namespace (Pods) of Kubernetes Networking?", "context": "", "answer": "[PROMQL] sum by (namespace) (rate(container_network_receive_packets_dropped_total{cluster=\"$cluster\",namespace!=\"\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) [/PROMQL]"}
{"question": "What is the rate of transmitted packets dropped in a Kubernetes Namespace (Pods) network?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_packets_dropped_total{cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval]) * on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}) by (pod) [/PROMQL]"}
{"question": "What is the current rate of bytes received for the Kubernetes workload within a namespace regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the current rate of bytes transmitted within the Kubernetes Namespace for workloads related to networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the receive bandwidth for a Kubernetes workload within a namespace regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the transmitted bandwidth for the workload in a Kubernetes Namespace regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the average container bandwidth for a Kubernetes namespace in terms of received data?", "context": "", "answer": "[PROMQL] sort_desc(avg(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the average container bandwidth by workload in terms of transmitted data within a Kubernetes namespace regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(avg(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of received packets for the workload in a Kubernetes namespace regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_packets_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of transmitted packets for the workload within the Kubernetes namespace regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_packets_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of received packets dropped in the specified Kubernetes namespace for networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_packets_dropped_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the rate of dropped packets in the specified Kubernetes namespace (workload) regarding networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_packets_dropped_total{cluster=\"$cluster\",namespace=\"$namespace\"}[$__rate_interval])\n* on (cluster,namespace,pod) kube_pod_info{host_network=\"false\"}\n* on (cluster,namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=\"$namespace\", workload=~\".+\", workload_type=~\"$type\"}) by (workload))\n [/PROMQL]"}
{"question": "What is the CPU utilization for the instance in the Cluster using the Node Exporter and USE method?", "context": "", "answer": "[PROMQL] ((\n  instance:node_cpu_utilisation:rate5m{job=\"node-exporter\", cluster=\"$cluster\"}\n  *\n  instance:node_num_cpu:sum{job=\"node-exporter\", cluster=\"$cluster\"}\n) != 0 )\n/ scalar(sum(instance:node_num_cpu:sum{job=\"node-exporter\", cluster=\"$cluster\"}))\n [/PROMQL]"}
{"question": "What is the CPU saturation (Load1 per CPU) for each instance in the Cluster using Node Exporter and the USE method?", "context": "", "answer": "[PROMQL] (\n  instance:node_load1_per_cpu:ratio{job=\"node-exporter\", cluster=\"$cluster\"}\n  / scalar(count(instance:node_load1_per_cpu:ratio{job=\"node-exporter\", cluster=\"$cluster\"}))\n)  != 0\n [/PROMQL]"}
{"question": "What is the Memory Utilization by instance in the Node Exporter using the USE method under the Cluster?", "context": "", "answer": "[PROMQL] (\n  instance:node_memory_utilisation:ratio{job=\"node-exporter\", cluster=\"$cluster\"}\n  / scalar(count(instance:node_memory_utilisation:ratio{job=\"node-exporter\", cluster=\"$cluster\"}))\n) != 0\n [/PROMQL]"}
{"question": "What is the Memory Saturation (Major Page Faults) by instance in the Node Exporter using the USE method and focused on the Cluster?", "context": "", "answer": "[PROMQL] instance:node_vmstat_pgmajfault:rate5m{job=\"node-exporter\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the network utilization (Bytes Received and Transmitted) per instance for Cluster: Network Utilisation using Node Exporter's USE method?", "context": "", "answer": "[PROMQL] instance:node_network_receive_bytes_excluding_lo:rate5m{job=\"node-exporter\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the network utilization (Bytes Transmit and Receive) for each instance in the cluster using Node Exporter and the USE method?", "context": "", "answer": "[PROMQL] instance:node_network_transmit_bytes_excluding_lo:rate5m{job=\"node-exporter\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the Network Saturation (Drops Receive/Transmit) by instance Receive using Node Exporter and the USE method, on the Cluster?", "context": "", "answer": "[PROMQL] instance:node_network_receive_drop_excluding_lo:rate5m{job=\"node-exporter\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the Network Saturation (Drops Receive/Transmit) by instance Transmit in the Node Exporter using the USE Method, under the Cluster?", "context": "", "answer": "[PROMQL] instance:node_network_transmit_drop_excluding_lo:rate5m{job=\"node-exporter\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the Disk I/O Utilization by instance and device for the Cluster in Node Exporter using the USE method?", "context": "", "answer": "[PROMQL] (\n  instance_device:node_disk_io_time_seconds:rate5m{job=\"node-exporter\", cluster=\"$cluster\"}\n  / scalar(count(instance_device:node_disk_io_time_seconds:rate5m{job=\"node-exporter\", cluster=\"$cluster\"}))\n) != 0\n [/PROMQL]"}
{"question": "What is the Disk IO Saturation for instance and device within the Cluster: Disk IO Saturation using Node Exporter / USE Method?", "context": "", "answer": "[PROMQL] (\n  instance_device:node_disk_io_time_weighted_seconds:rate5m{job=\"node-exporter\", cluster=\"$cluster\"}\n  / scalar(count(instance_device:node_disk_io_time_weighted_seconds:rate5m{job=\"node-exporter\", cluster=\"$cluster\"}))\n) != 0\n [/PROMQL]"}
{"question": "What is the disk space utilization by instance in the Cluster using Node Exporter and the USE method?", "context": "", "answer": "[PROMQL] sum without (device) (\n  max without (fstype, mountpoint) ((\n    node_filesystem_size_bytes{job=\"node-exporter\", fstype!=\"\", mountpoint!=\"\", cluster=\"$cluster\"}\n    -\n    node_filesystem_avail_bytes{job=\"node-exporter\", fstype!=\"\", mountpoint!=\"\", cluster=\"$cluster\"}\n  ) != 0)\n)\n/ scalar(sum(max without (fstype, mountpoint) (node_filesystem_size_bytes{job=\"node-exporter\", fstype!=\"\", mountpoint!=\"\", cluster=\"$cluster\"})))\n [/PROMQL]"}
{"question": "What is the CPU utilization for the 'Node' using the 'USE Method' with Node Exporter?", "context": "", "answer": "[PROMQL] instance:node_cpu_utilisation:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the CPU saturation (Load1 per CPU) for Node: CPU Saturation using the USE method with Node Exporter?", "context": "", "answer": "[PROMQL] instance:node_load1_per_cpu:ratio{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the memory utilization of the Node in Node Exporter using the USE method?", "context": "", "answer": "[PROMQL] instance:node_memory_utilisation:ratio{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the major page faults value for Node: Memory Saturation using the Node Exporter / USE Method?", "context": "", "answer": "[PROMQL] instance:node_vmstat_pgmajfault:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the current Node: Network Utilisation (Bytes Received and Transmitted) for the 'Node Exporter' using the 'USE Method'?", "context": "", "answer": "[PROMQL] instance:node_network_receive_bytes_excluding_lo:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the value of 'Network Utilisation (Bytes Transmit)' for 'Node' using the 'Node Exporter / USE Method'?", "context": "", "answer": "[PROMQL] instance:node_network_transmit_bytes_excluding_lo:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the value of Node: Network Saturation (Drops Receive) using the Node Exporter / USE Method?", "context": "", "answer": "[PROMQL] instance:node_network_receive_drop_excluding_lo:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the Network Saturation (Drops Receive/Transmit) - Transmit value for the Node Exporter using the USE method on Node: Network?", "context": "", "answer": "[PROMQL] instance:node_network_transmit_drop_excluding_lo:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the Disk IO Utilization by device using the Node Exporter and the USE method on Node?", "context": "", "answer": "[PROMQL] instance_device:node_disk_io_time_seconds:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the Disk IO Saturation by device using Node Exporter and the USE method on Node: [Node Name]?", "context": "", "answer": "[PROMQL] instance_device:node_disk_io_time_weighted_seconds:rate5m{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} != 0 [/PROMQL]"}
{"question": "What is the disk space utilization by device using Node Exorter's USE method for Node: Disk Space Utilisation?", "context": "", "answer": "[PROMQL] sort_desc(1 -\n  (\n   max without (mountpoint, fstype) (node_filesystem_avail_bytes{job=\"node-exporter\", fstype!=\"\", instance=\"$instance\", cluster=\"$cluster\"})\n   /\n   max without (mountpoint, fstype) (node_filesystem_size_bytes{job=\"node-exporter\", fstype!=\"\", instance=\"$instance\", cluster=\"$cluster\"})\n  ) != 0\n)\n [/PROMQL]"}
{"question": "What is the CPU usage of 'cpu' on Node Exporter for MacOS?", "context": "", "answer": "[PROMQL] (\n  (1 - sum without (mode) (rate(node_cpu_seconds_total{job=\"node-exporter\", mode=~\"idle|iowait|steal\", instance=\"$instance\", cluster=\"$cluster\"}[$__rate_interval])))\n/ ignoring(cpu) group_left\n  count without (cpu, mode) (node_cpu_seconds_total{job=\"node-exporter\", mode=\"idle\", instance=\"$instance\", cluster=\"$cluster\"})\n)\n [/PROMQL]"}
{"question": "What is the 1m load average for Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] node_load1{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the 5-minute load average on Node Exporter for MacOS?", "context": "", "answer": "[PROMQL] node_load5{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the 15-minute load average on Node Exporter for MacOS?", "context": "", "answer": "[PROMQL] node_load15{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the load average for logical cores on Node Exporter in MacOS?", "context": "", "answer": "[PROMQL] count(node_cpu_seconds_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", mode=\"idle\"}) [/PROMQL]"}
{"question": "What is the current memory usage of physical memory in Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] node_memory_total_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the memory usage (Memory Used) for Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] (\n    node_memory_internal_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} -\n    node_memory_purgeable_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} +\n    node_memory_wired_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} +\n    node_memory_compressed_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}\n)\n [/PROMQL]"}
{"question": "What is the memory usage of applications in MacOS as reported by Node Exporter?", "context": "", "answer": "[PROMQL] (\n    node_memory_internal_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} -\n    node_memory_purgeable_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}\n)\n [/PROMQL]"}
{"question": "What is the Memory Usage (Wired Memory) for Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] node_memory_wired_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the memory usage (compressed) for Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] node_memory_compressed_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the memory usage of Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] (\n    (\n      avg(node_memory_internal_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}) -\n      avg(node_memory_purgeable_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}) +\n      avg(node_memory_wired_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}) +\n      avg(node_memory_compressed_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"})\n    ) /\n    avg(node_memory_total_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"})\n)\n*\n100\n [/PROMQL]"}
{"question": "What is the Disk I/O by device read for Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] rate(node_disk_read_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\"}[$__rate_interval]) [/PROMQL]"}
{"question": "What is the Disk I/O by device written for Node Exporter on MacOS?", "context": "", "answer": "[PROMQL] rate(node_disk_written_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\"}[$__rate_interval]) [/PROMQL]"}
{"question": "What is the Disk I/O by device io time on Node Exporter for MacOS?", "context": "", "answer": "[PROMQL] rate(node_disk_io_time_seconds_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\"}[$__rate_interval]) [/PROMQL]"}
{"question": "What network is being received on the device in Node Exporter/MacOS?", "context": "", "answer": "[PROMQL] rate(node_network_receive_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device!=\"lo\"}[$__rate_interval]) * 8 [/PROMQL]"}
{"question": "What network is being transmitted by the device on Node Exporter for MacOS?", "context": "", "answer": "[PROMQL] rate(node_network_transmit_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device!=\"lo\"}[$__rate_interval]) * 8 [/PROMQL]"}
{"question": "What is the CPU usage by cpu in Node Exporter / Nodes?", "context": "", "answer": "[PROMQL] (\n  (1 - sum without (mode) (rate(node_cpu_seconds_total{job=\"node-exporter\", mode=~\"idle|iowait|steal\", instance=\"$instance\", cluster=\"$cluster\"}[$__rate_interval])))\n/ ignoring(cpu) group_left\n  count without (cpu, mode) (node_cpu_seconds_total{job=\"node-exporter\", mode=\"idle\", instance=\"$instance\", cluster=\"$cluster\"})\n)\n [/PROMQL]"}
{"question": "What is the 1-minute load average for Node Exporter/Nodes?", "context": "", "answer": "[PROMQL] node_load1{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the 5-minute load average for Node Exporter's nodes?", "context": "", "answer": "[PROMQL] node_load5{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the 15-minute load average for Node Exporter's nodes?", "context": "", "answer": "[PROMQL] node_load15{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the load average for logical cores in Node Exporter?", "context": "", "answer": "[PROMQL] count(node_cpu_seconds_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", mode=\"idle\"}) [/PROMQL]"}
{"question": "What is the current memory usage of Node Exporter nodes?", "context": "", "answer": "[PROMQL] (\n  node_memory_MemTotal_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}\n-\n  node_memory_MemFree_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}\n-\n  node_memory_Buffers_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}\n-\n  node_memory_Cached_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}\n)\n [/PROMQL]"}
{"question": "What is the Memory Usage of memory buffers in Node Exporter / Nodes?", "context": "", "answer": "[PROMQL] node_memory_Buffers_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the Memory Usage (cached) for Node Exporter/Nodes?", "context": "", "answer": "[PROMQL] node_memory_Cached_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the current memory usage (free) of Node Exporter nodes?", "context": "", "answer": "[PROMQL] node_memory_MemFree_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"} [/PROMQL]"}
{"question": "What is the Memory Usage of Node Exporter nodes?", "context": "", "answer": "[PROMQL] 100 -\n(\n  avg(node_memory_MemAvailable_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"}) /\n  avg(node_memory_MemTotal_bytes{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\"})\n* 100\n)\n [/PROMQL]"}
{"question": "What is the Disk I/O by device read for Node Exporter's Nodes?", "context": "", "answer": "[PROMQL] rate(node_disk_read_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\"}[$__rate_interval]) [/PROMQL]"}
{"question": "What is the Disk I/O by device written for Node Exporter / Nodes?", "context": "", "answer": "[PROMQL] rate(node_disk_written_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\"}[$__rate_interval]) [/PROMQL]"}
{"question": "What is the Disk I/O by device io time for Node Exporter / Nodes?", "context": "", "answer": "[PROMQL] rate(node_disk_io_time_seconds_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device=~\"(/dev/)?(mmcblk.p.+|nvme.+|rbd.+|sd.+|vd.+|xvd.+|dm-.+|md.+|dasd.+)\"}[$__rate_interval]) [/PROMQL]"}
{"question": "What is the network received by device in Node Exporter / Nodes?", "context": "", "answer": "[PROMQL] rate(node_network_receive_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device!=\"lo\"}[$__rate_interval]) * 8 [/PROMQL]"}
{"question": "What network is being transmitted by device 'Node Exporter / Nodes'?", "context": "", "answer": "[PROMQL] rate(node_network_transmit_bytes_total{job=\"node-exporter\", instance=\"$instance\", cluster=\"$cluster\", device!=\"lo\"}[$__rate_interval]) * 8 [/PROMQL]"}
{"question": "What is the used space for Volume Space Usage in Kubernetes Persistent Volumes?", "context": "", "answer": "[PROMQL] (\n  sum without(instance, node) (topk(1, (kubelet_volume_stats_capacity_bytes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})))\n  -\n  sum without(instance, node) (topk(1, (kubelet_volume_stats_available_bytes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})))\n)\n [/PROMQL]"}
{"question": "What is the current free space usage for Kubernetes Persistent Volumes?", "context": "", "answer": "[PROMQL] sum without(instance, node) (topk(1, (kubelet_volume_stats_available_bytes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})))\n [/PROMQL]"}
{"question": "What is the current usage of persistent volume space in Kubernetes?", "context": "", "answer": "[PROMQL] max without(instance,node) (\n(\n  topk(1, kubelet_volume_stats_capacity_bytes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})\n  -\n  topk(1, kubelet_volume_stats_available_bytes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})\n)\n/\ntopk(1, kubelet_volume_stats_capacity_bytes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})\n* 100)\n [/PROMQL]"}
{"question": "What is the used inodes count for persistent volumes in Kubernetes?", "context": "", "answer": "[PROMQL] sum without(instance, node) (topk(1, (kubelet_volume_stats_inodes_used{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"}))) [/PROMQL]"}
{"question": "What is the free inodes usage of the Persistent Volumes in Kubernetes?", "context": "", "answer": "[PROMQL] (\n  sum without(instance, node) (topk(1, (kubelet_volume_stats_inodes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})))\n  -\n  sum without(instance, node) (topk(1, (kubelet_volume_stats_inodes_used{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})))\n)\n [/PROMQL]"}
{"question": "What is the usage of volume inodes in Kubernetes' Persistent Volumes?", "context": "", "answer": "[PROMQL] max without(instance,node) (\ntopk(1, kubelet_volume_stats_inodes_used{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})\n/\ntopk(1, kubelet_volume_stats_inodes{cluster=\"$cluster\", job=\"kubelet\", metrics_path=\"/metrics\", namespace=\"$namespace\", persistentvolumeclaim=\"$volume\"})\n* 100)\n [/PROMQL]"}
{"question": "What is the current rate of bytes received for the Kubernetes Pod regarding networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the current rate of bytes transmitted in the Kubernetes Pod regarding networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the receive bandwidth for a Kubernetes Pod within its networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the transmitted bandwidth for a Kubernetes Pod in its networking setup?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_bytes_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of received packets for each Kubernetes pod in terms of networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_packets_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate of transmitted packets in a Kubernetes Pod regarding networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_packets_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate at which packets received by a Kubernetes Pod are dropped in relation to networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_receive_packets_dropped_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the rate at which packets are dropped when transmitted within a Kubernetes pod's networking?", "context": "", "answer": "[PROMQL] sum(rate(container_network_transmit_packets_dropped_total{cluster=\"$cluster\",namespace=~\"$namespace\", pod=~\"$pod\"}[$__rate_interval])) by (pod) [/PROMQL]"}
{"question": "What is the highest timestamp in comparison to the highest timestamps sent by cluster, instance, remote_name, and URL for Prometheus (Remote Write)?", "context": "", "answer": "[PROMQL] (\n  prometheus_remote_storage_highest_timestamp_in_seconds{cluster=~\"$cluster\", instance=~\"$instance\"} \n-  \n  ignoring(remote_name, url) group_right(instance) (prometheus_remote_storage_queue_highest_sent_timestamp_seconds{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} != 0)\n)\n [/PROMQL]"}
{"question": "What is the rate for Prometheus, broken down by cluster, instance, remote_name, and URL over a 5-minute interval?", "context": "", "answer": "[PROMQL] clamp_min(\n  rate(prometheus_remote_storage_highest_timestamp_in_seconds{cluster=~\"$cluster\", instance=~\"$instance\"}[5m])  \n- \n  ignoring (remote_name, url) group_right(instance) rate(prometheus_remote_storage_queue_highest_sent_timestamp_seconds{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m])\n, 0)\n [/PROMQL]"}
{"question": "What is the rate, success or drop of Prometheus Remote Write operations, grouped by cluster, instance, remote_name, and URL, over a 5-minute period?", "context": "", "answer": "[PROMQL] rate(\n  prometheus_remote_storage_samples_in_total{cluster=~\"$cluster\", instance=~\"$instance\"}[5m])\n- \n  ignoring(remote_name, url) group_right(instance) (rate(prometheus_remote_storage_succeeded_samples_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) or rate(prometheus_remote_storage_samples_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]))\n- \n  (rate(prometheus_remote_storage_dropped_samples_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) or rate(prometheus_remote_storage_samples_dropped_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]))\n [/PROMQL]"}
{"question": "What are the current shards, grouped by cluster, instance, remote_name, and URL, in Prometheus (Remote Write perspective)?", "context": "", "answer": "[PROMQL] prometheus_remote_storage_shards{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} [/PROMQL]"}
{"question": "What is the maximum number of shards for each cluster, instance, remote_name, and URL in Prometheus (Remote Write)?", "context": "", "answer": "[PROMQL] prometheus_remote_storage_shards_max{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} [/PROMQL]"}
{"question": "What is the value of 'Prometheus/Remote Write' for min shards grouped by cluster, instance, remote_name, and URL?", "context": "", "answer": "[PROMQL] prometheus_remote_storage_shards_min{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} [/PROMQL]"}
{"question": "What are the desired shards, grouped by cluster, instance, remote_name, and URL, for Prometheus: Remote Write?", "context": "", "answer": "[PROMQL] prometheus_remote_storage_shards_desired{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} [/PROMQL]"}
{"question": "What is the shard capacity of Prometheus, grouped by cluster, instance, remote_name, and URL?", "context": "", "answer": "[PROMQL] prometheus_remote_storage_shard_capacity{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} [/PROMQL]"}
{"question": "What are the pending samples, grouped by cluster, instance, remote_name, and URL, in Prometheus (Remote Write)?", "context": "", "answer": "[PROMQL] prometheus_remote_storage_pending_samples{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} or prometheus_remote_storage_samples_pending{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"} [/PROMQL]"}
{"question": "What is the current segment of Prometheus's Remote Write: TSDB, grouped by cluster and instance?", "context": "", "answer": "[PROMQL] prometheus_tsdb_wal_segment_current{cluster=~\"$cluster\", instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the current segment of Remote Write operation for each cluster, instance, and consumer in Prometheus?", "context": "", "answer": "[PROMQL] prometheus_wal_watcher_current_segment{cluster=~\"$cluster\", instance=~\"$instance\"} [/PROMQL]"}
{"question": "Which samples were dropped by cluster, instance, remote_name, and URL in Prometheus (Remote Write)?", "context": "", "answer": "[PROMQL] rate(prometheus_remote_storage_dropped_samples_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) or rate(prometheus_remote_storage_samples_dropped_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) [/PROMQL]"}
{"question": "What are the failed samples for Prometheus, grouped by cluster, instance, remote_name, and URL?", "context": "", "answer": "[PROMQL] rate(prometheus_remote_storage_failed_samples_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) or rate(prometheus_remote_storage_samples_failed_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) [/PROMQL]"}
{"question": "What are the retried samples for each cluster, instance, remote_name, and URL in Prometheus (Remote Write)?", "context": "", "answer": "[PROMQL] rate(prometheus_remote_storage_retried_samples_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) or rate(prometheus_remote_storage_samples_retried_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) [/PROMQL]"}
{"question": "What are the enqueued retries for each cluster, instance, remote_name, and URL in Prometheus (Remote Write)?", "context": "", "answer": "[PROMQL] rate(prometheus_remote_storage_enqueue_retries_total{cluster=~\"$cluster\", instance=~\"$instance\", url=~\"$url\"}[5m]) [/PROMQL]"}
{"question": "What is the overview of Prometheus regarding Target Sync for cluster, job, instance, and scrape_job?", "context": "", "answer": "[PROMQL] sum(rate(prometheus_target_sync_length_seconds_sum{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"}[5m])) by (cluster, job, scrape_job, instance) * 1e3 [/PROMQL]"}
{"question": "What is the breakdown of targets by cluster, job, and instance for Prometheus?", "context": "", "answer": "[PROMQL] sum by (cluster, job, instance) (prometheus_sd_discovered_targets{cluster=~\"$cluster\", job=~\"$job\",instance=~\"$instance\"}) [/PROMQL]"}
{"question": "What is the average scrape interval duration for each cluster, job, instance, and interval configuration?", "context": "", "answer": "[PROMQL] rate(prometheus_target_interval_length_seconds_sum{cluster=~\"$cluster\", job=~\"$job\",instance=~\"$instance\"}[5m]) / rate(prometheus_target_interval_length_seconds_count{cluster=~\"$cluster\", job=~\"$job\",instance=~\"$instance\"}[5m]) * 1e3 [/PROMQL]"}
{"question": "What are the scrape failures, grouped by cluster, job, and instance, that have exceeded the body size limit in Prometheus?", "context": "", "answer": "[PROMQL] sum by (cluster, job, instance) (rate(prometheus_target_scrapes_exceeded_body_size_limit_total{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"}[1m])) [/PROMQL]"}
{"question": "What are the scrape failures, grouped by cluster, job, and instance, where the sample limit was exceeded, regarding Prometheus?", "context": "", "answer": "[PROMQL] sum by (cluster, job, instance) (rate(prometheus_target_scrapes_exceeded_sample_limit_total{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"}[1m])) [/PROMQL]"}
{"question": "What is the overview of Prometheus for scraping failures, grouped by cluster, job, and instance with duplicated timestamps?", "context": "", "answer": "[PROMQL] sum by (cluster, job, instance) (rate(prometheus_target_scrapes_sample_duplicate_timestamp_total{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"}[1m])) [/PROMQL]"}
{"question": "What are the scrape failures for each cluster, job, and instance that are beyond the specified bounds in Prometheus?", "context": "", "answer": "[PROMQL] sum by (cluster, job, instance) (rate(prometheus_target_scrapes_sample_out_of_bounds_total{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"}[1m])) [/PROMQL]"}
{"question": "What is the process for scraping failures by cluster, job, and instance, in an out-of-order fashion, regarding Prometheus's overview?", "context": "", "answer": "[PROMQL] sum by (cluster, job, instance) (rate(prometheus_target_scrapes_sample_out_of_order_total{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"}[1m])) [/PROMQL]"}
{"question": "What is an overview of the appended samples grouped by cluster, job, and instance in Prometheus?", "context": "", "answer": "[PROMQL] rate(prometheus_tsdb_head_samples_appended_total{cluster=~\"$cluster\", job=~\"$job\",instance=~\"$instance\"}[5m]) [/PROMQL]"}
{"question": "What is the overview of the Head Series for each cluster, job, and instance in Prometheus?", "context": "", "answer": "[PROMQL] prometheus_tsdb_head_series{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is an overview of Head Chunks by cluster, job, and instance for Prometheus?", "context": "", "answer": "[PROMQL] prometheus_tsdb_head_chunks{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the query rate for each cluster, job, and instance in Prometheus?", "context": "", "answer": "[PROMQL] rate(prometheus_engine_query_duration_seconds_count{cluster=~\"$cluster\",job=~\"$job\",instance=~\"$instance\",slice=\"inner_eval\"}[5m]) [/PROMQL]"}
{"question": "What is the stage duration for each slice in the overview of Prometheus?", "context": "", "answer": "[PROMQL] max by (slice) (prometheus_engine_query_duration_seconds{quantile=\"0.9\",cluster=~\"$cluster\", job=~\"$job\",instance=~\"$instance\"}) * 1e3 [/PROMQL]"}
{"question": "Is Kubernetes/Proxy currently up?", "context": "", "answer": "[PROMQL] sum(up{cluster=\"$cluster\", job=\"kube-proxy\"}) [/PROMQL]"}
{"question": "What is the Rules Sync Rate for Kubernetes Proxy?", "context": "", "answer": "[PROMQL] sum(rate(kubeproxy_sync_proxy_rules_duration_seconds_count{cluster=\"$cluster\", job=\"kube-proxy\", instance=~\"$instance\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the 99th quantile of Kubernetes Proxy Rules Sync Latency per instance?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99,rate(kubeproxy_sync_proxy_rules_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-proxy\", instance=~\"$instance\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the network programming rate for Kubernetes Proxy?", "context": "", "answer": "[PROMQL] sum(rate(kubeproxy_network_programming_duration_seconds_count{cluster=\"$cluster\", job=\"kube-proxy\", instance=~\"$instance\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the 99th quantile of Network Programming Latency for Kubernetes instances via Proxy?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(kubeproxy_network_programming_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-proxy\", instance=~\"$instance\"}[$__rate_interval])) by (instance, le)) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for Kubernetes Proxy?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kube-proxy\", instance=~\"$instance\",code=~\"2..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for Kubernetes Proxy?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kube-proxy\", instance=~\"$instance\",code=~\"3..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for the Kubernetes Proxy?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kube-proxy\", instance=~\"$instance\",code=~\"4..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kubernetes Kube API Request Rate for status code 5xx via Proxy?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\",job=\"kube-proxy\", instance=~\"$instance\",code=~\"5..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the 99th quantile post request latency, grouped by verb and URL, in Kubernetes Proxy?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-proxy\",instance=~\"$instance\",verb=\"POST\"}[$__rate_interval])) by (verb, url, le)) [/PROMQL]"}
{"question": "What is the 99th quantile request latency, grouped by verb and URL, in Kubernetes' proxy?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-proxy\", instance=~\"$instance\", verb=\"GET\"}[$__rate_interval])) by (verb, url, le)) [/PROMQL]"}
{"question": "What is the memory usage for each Kubernetes instance via the proxy?", "context": "", "answer": "[PROMQL] process_resident_memory_bytes{cluster=\"$cluster\", job=\"kube-proxy\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the CPU usage of the Kubernetes instance via the Proxy?", "context": "", "answer": "[PROMQL] rate(process_cpu_seconds_total{cluster=\"$cluster\", job=\"kube-proxy\",instance=~\"$instance\"}[$__rate_interval]) [/PROMQL]"}
{"question": "Are Goroutines in Kubernetes managed per instance via a Proxy?", "context": "", "answer": "[PROMQL] go_goroutines{cluster=\"$cluster\", job=\"kube-proxy\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "Is the Kubernetes Scheduler currently operational (Up)?", "context": "", "answer": "[PROMQL] sum(up{cluster=\"$cluster\", job=\"kube-scheduler\"}) [/PROMQL]"}
{"question": "What is the end-to-end scheduling rate for Kubernetes, considering both cluster and instance levels?", "context": "", "answer": "[PROMQL] sum(rate(scheduler_e2e_scheduling_duration_seconds_count{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance) [/PROMQL]"}
{"question": "What is the scheduling rate for Kubernetes, considering both cluster and instance binding?", "context": "", "answer": "[PROMQL] sum(rate(scheduler_binding_duration_seconds_count{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance) [/PROMQL]"}
{"question": "What is the scheduling rate for Kubernetes, considering both cluster and instance scheduling algorithms?", "context": "", "answer": "[PROMQL] sum(rate(scheduler_scheduling_algorithm_duration_seconds_count{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance) [/PROMQL]"}
{"question": "What is the scheduling rate for Kubernetes clusters, considering their respective volumes?", "context": "", "answer": "[PROMQL] sum(rate(scheduler_volume_scheduling_duration_seconds_count{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance) [/PROMQL]"}
{"question": "What is the scheduling latency 99th quantile, end-to-end (e2e), for each Kubernetes cluster and instance in terms of scheduler performance?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(scheduler_e2e_scheduling_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-scheduler\",instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, le)) [/PROMQL]"}
{"question": "What is the 99th quantile scheduling latency for Kubernetes, broken down by cluster and instance binding?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(scheduler_binding_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-scheduler\",instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, le)) [/PROMQL]"}
{"question": "What is the 99th quantile scheduling latency for each cluster and instance scheduling algorithm in Kubernetes?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(scheduler_scheduling_algorithm_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-scheduler\",instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, le)) [/PROMQL]"}
{"question": "What is the 99th quantile scheduling latency for Kubernetes, broken down by cluster and instance volume?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(scheduler_volume_scheduling_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-scheduler\",instance=~\"$instance\"}[$__rate_interval])) by (cluster, instance, le)) [/PROMQL]"}
{"question": "What is the Kube API Request Rate for the Kubernetes Scheduler?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\",code=~\"2..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kube API Request Rate in the Kubernetes Scheduler, specifically for responses with status codes 3xx?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\",code=~\"3..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kubernetes Scheduler's Kube API Request Rate for status code 4xx?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\",code=~\"4..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the Kubernetes Scheduler's Kube API Request Rate for status 5xx?", "context": "", "answer": "[PROMQL] sum(rate(rest_client_requests_total{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\",code=~\"5..\"}[$__rate_interval])) [/PROMQL]"}
{"question": "What is the 99th quantile post request latency for Kubernetes Scheduler, grouped by verb and URL?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\", verb=\"POST\"}[$__rate_interval])) by (verb, url, le)) [/PROMQL]"}
{"question": "What is the 99th quantile request latency, grouped by verb and URL, in the Kubernetes Scheduler?", "context": "", "answer": "[PROMQL] histogram_quantile(0.99, sum(rate(rest_client_request_duration_seconds_bucket{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\", verb=\"GET\"}[$__rate_interval])) by (verb, url, le)) [/PROMQL]"}
{"question": "What is the memory allocated per instance by the Kubernetes Scheduler?", "context": "", "answer": "[PROMQL] process_resident_memory_bytes{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the CPU usage by instance in Kubernetes Scheduler?", "context": "", "answer": "[PROMQL] rate(process_cpu_seconds_total{cluster=\"$cluster\", job=\"kube-scheduler\", instance=~\"$instance\"}[$__rate_interval]) [/PROMQL]"}
{"question": "Are Goroutines in Kubernetes Scheduler used per instance?", "context": "", "answer": "[PROMQL] go_goroutines{cluster=\"$cluster\", job=\"kube-scheduler\",instance=~\"$instance\"} [/PROMQL]"}
{"question": "What is the current rate of bytes received for Kubernetes's networked workloads?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the current rate of bytes transmitted for Kubernetes workloads in terms of networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the average rate of bytes received for Kubernetes workloads in terms of networking?", "context": "", "answer": "[PROMQL] sort_desc(avg(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the average rate of bytes transmitted for Kubernetes workloads in terms of networking?", "context": "", "answer": "[PROMQL] sort_desc(avg(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the receive bandwidth for Kubernetes workloads within the networking setup?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the method for transmitting bandwidth in Kubernetes networking for workloads?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_bytes_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate of received packets in Kubernetes networking for workloads?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate of transmitted packets in Kubernetes networking with respect to workloads?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_packets_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate at which packets received within the Kubernetes workload's networking are dropped?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_receive_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}
{"question": "What is the rate at which packets are dropped in Kubernetes workload networking?", "context": "", "answer": "[PROMQL] sort_desc(sum(rate(container_network_transmit_packets_dropped_total{job=\"kubelet\", metrics_path=\"/metrics/cadvisor\", cluster=\"$cluster\",namespace=~\"$namespace\"}[$__rate_interval])\n* on (namespace,pod)\ngroup_left(workload,workload_type) namespace_workload_pod:kube_pod_owner:relabel{cluster=\"$cluster\",namespace=~\"$namespace\", workload=~\"$workload\", workload_type=~\"$type\"}) by (pod))\n [/PROMQL]"}