promql_train_data.json

[
    {
        "instruction": "which kubernetes metric tracks the Percent of time the CPU spent in an idle state",
        "input": "",
        "output": "system_cpu_idle"
    },
    {
        "instruction": "In the last hour, show me the time percentage for which the cpu was in idle state in the target kubernetes cluster and orgid org_id.",
        "input": "",
        "output": "(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h]"
    },
    {
        "instruction": "How much percent of time the CPU was in the idle state in the past 45 minutes in the target kubernetes cluster and orgid org_id?",
        "input": "",
        "output": "(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[45m]"
    },
    {
        "instruction": "show me the time percentage for which the cpu was in idle state in the target kubernetes cluster, n2-highmem-16 instance_type and region us-west1-a",
        "input": "",
        "output": "(system_cpu_idle{kube_cluster_name=\"target\", instance_type=\"n2-highmem-16\", region=\"us-west1-a\"}"
    },
    {
        "instruction": "Show me the average CPU idle state percentage over a 5 minute window in kubernetes cluster target and org_id orgid",
        "input": "",
        "output": "avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Tell me the sum of CPU idle state percentage over the last 24 hours in the target kubernetes cluster and orgid org_id",
        "input": "",
        "output": "sum_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[24h])"
    },
    {
        "instruction": "Can you show me the minimum percentage CPU idle state over a 1-hour window in the target kubernetes cluster and orgid org_id",
        "input": "",
        "output": "min_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h])"
    },
    {
        "instruction": "Show me the rate of change in CPU idle state percentage over the last 5 minutes for target cluster and orgid organization",
        "input": "",
        "output": "rate(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Show me the difference in percentage of CPU idle state between 1 hour ago and now",
        "input": "",
        "output": "delta(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h])"
    },
    {
        "instruction": "Sum of CPU percentage in idle state across all hosts:",
        "input": "",
        "output": "sum(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "show the average percentage CPU idle state across all hosts.",
        "input": "",
        "output": "avg(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "show the maximum CPU idle state percent across all hosts:",
        "input": "",
        "output": "max(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the minimum percentage of CPU idle state across all hosts:",
        "input": "",
        "output": "min(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the standard deviation of CPU idle percent across all hosts:",
        "input": "",
        "output": "stddev(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the count of hosts where CPU idle state percentage is below a threshold of 20%",
        "input": "",
        "output": "count(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"} < 20)"
    },
    {
        "instruction": "Calculate the average CPU idle state percentage over a 5-minute window, aggregated by host:",
        "input": "",
        "output": "avg by (host) (avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "Find the maximum CPU idle state percentage over a 15-minute window, aggregated by instance_type",
        "input": "",
        "output": "max by (instance_type) (max_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[15m]))"
    },
    {
        "instruction": "Sum the CPU idle state percentage over the last hour, aggregated by host for the last hour.",
        "input": "",
        "output": "sum by (host) (sum_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h]))"
    },
    {
        "instruction": "Calculate the average CPU idle percentage over a 10-minute window, aggregated by host and instance_type",
        "input": "",
        "output": "avg by (host, instance_type) (avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[10m]))"
    },
    {
        "instruction": "Find the minimum CPU idle percentage over the last 24 hours, aggregated by cluster_name dev and region us-west1:",
        "input": "",
        "output": "min by (dev, us-west1) (min_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[24h]))"
    },
    {
        "instruction": "In the last hour, show me the amount of memory in use for the cluster target and oraganization id orgid",
        "input": "",
        "output": "(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h]"
    },
    {
        "instruction": "How much amount of memory was in use for the cluster target and oraganization id orgid in the past 45 minutes",
        "input": "",
        "output": "(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[45m]"
    },
    {
        "instruction": "show me the amount of ram usage in the target kubernetes cluster, n2-highmem-16 instance_type and region us-west1-a",
        "input": "",
        "output": "(system_mem_used{kube_cluster_name=\"target\", instance_type=\"n2-highmem-16\", region=\"us-west1-a\"})"
    },
    {
        "instruction": "Show me the average amount of ram used 5 minute window in kubernetes cluster target and org_id orgid",
        "input": "",
        "output": "avg_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Tell me the sum of ram used over the last 24 hours in the target kubernetes cluster and orgid org_id",
        "input": "",
        "output": "sum_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[24h])"
    },
    {
        "instruction": "Can you show me the minimum amount of ram usage over a 1-hour window in the target kubernetes cluster and orgid org_id",
        "input": "",
        "output": "min_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h])"
    },
    {
        "instruction": "Show me the rate of change in the ram usage percentage over the last 5 minutes for target cluster and orgid organization",
        "input": "",
        "output": "rate(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Show me the difference in ram usage between 1 hour ago and now",
        "input": "",
        "output": "delta(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h])"
    },
    {
        "instruction": "Sum of ram usage across all hosts:",
        "input": "",
        "output": "sum(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "show the average percentage CPU idle state across all hosts.",
        "input": "",
        "output": "avg(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "show the maximum amount of ram used across all hosts:",
        "input": "",
        "output": "max(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the minimum amount of ram used across all hosts:",
        "input": "",
        "output": "min(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the standard deviation of RAM usage across all hosts:",
        "input": "",
        "output": "stddev(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the count of hosts where ram usage is below a threshold of 20%",
        "input": "",
        "output": "count(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"} < 20)"
    },
    {
        "instruction": "Calculate the average ram usage over a 5-minute window, aggregated by host:",
        "input": "",
        "output": "avg by (host) (avg_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "Find the maximum ram usage over a 15-minute window, aggregated by instance_type",
        "input": "",
        "output": "max by (instance_type) (max_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[15m]))"
    },
    {
        "instruction": "Sum the amount of ram usage over the last hour, aggregated by host for the last hour.",
        "input": "",
        "output": "sum by (host) (sum_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h]))"
    },
    {
        "instruction": "Calculate the average ram usage over a 10-minute window, aggregated by host host and instance_type instance_type",
        "input": "",
        "output": "avg by (host, instance_type) (avg_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[10m]))"
    },
    {
        "instruction": "Find the minimum ram usage over the last 24 hours, aggregated by cluster_name as dev",
        "input": "",
        "output": "min by (dev) (min_over_time(system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}[24h]))"
    },
    {
        "instruction": "Show the average over 5 minutes for average CPU usage per host where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "avg by (host) (100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "which promql function is used to calculate the average value of all points in the specified interval",
        "input": "",
        "output": "avg_over_time(range-interval)"
    },
    {
        "instruction": "list of labels used with system_cpu_idle",
        "input": "",
        "output": "availability_zone, host, kube_cluster_name, kfuse, org_id, project, region, instance_type"
    },
    {
        "instruction": "Show the average CPU usage per host averaged over 5 minutes where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "avg by (host) (100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "show average cpu usage per host for \"target\" cluster and orgid organization averaged over 5 minutes",
        "input": "",
        "output": "avg by (host) (100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "Show the average over 5 minutes for maximum CPU usage over 5 minutes per host where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "max by (host) (100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "Calculate the sum of average CPU usage in the last 15 minutes for each host where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "sum by (host) (100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[15m]))"
    },
    {
        "instruction": "Return the count of the average CPU usage greater than 80 in the last 5 minutes for each host where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "count_over_time((100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])) > 80)"
    },
    {
        "instruction": "Show the average CPU usage averaged over an hour per host where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "avg by (host) (100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h]))"
    },
    {
        "instruction": "Return the rate of change in average CPU usage by host in the target cluster and orgid organization in the last 5 min",
        "input": "",
        "output": "rate(100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])) * 60"
    },
    {
        "instruction": "Show the percentage of average CPU usage over 5 minutes for each host where the cluster name is target and organization id is orgid",
        "input": "",
        "output": "100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Calculate the difference in average CPU usage over the last 5 minutes and 1 hour ago by host in the \"target\" cluster and \"orgid\" organization",
        "input": "",
        "output": "delta(100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))[1h]"
    },
    {
        "instruction": "Calculate the 90th percentile of average CPU usage within 5 minutes by host in the target cluster and orgid organization",
        "input": "",
        "output": "quantile_over_time(0.90, 100 - avg_over_time(system_cpu_idle{kube_cluster_name=\"target\", org_id=\"orgId\"[5m]}))"
    },
    {
        "instruction": "Return the amount of ram in use for the cluster target and oraganization id orgid",
        "input": "",
        "output": "system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}"
    },
    {
        "instruction": "Show the amount of memory in use for the cluster target and oraganization id orgid",
        "input": "",
        "output": "system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}"
    },
    {
        "instruction": "Show the average amount of memory in use for the cluster target and oraganization id orgid per host",
        "input": "",
        "output": "avg by(host) system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}"
    },
    {
        "instruction": "Return the average memory usage percentage for each host with cluster name as target and oraganization id as orgid",
        "input": "",
        "output": "avg by (host) (system_mem_used{kube_cluster_name=\"target\", org_id=\"orgId\"}/system_mem_total{kube_cluster_name=\"target\", org_id=\"orgId\"}*100)"
    },
    {
        "instruction": "How much amount of total memory was in use by the container for the cluster target and oraganization id orgid in the past 45 minutes",
        "input": "",
        "output": "container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[45m]"
    },
    {
        "instruction": "show me the amount of container memory usage in the target kubernetes cluster, n2-highmem-16 instance_type and region us-west1-a",
        "input": "",
        "output": "(container_memory_usage{kube_cluster_name=\"target\", instance_type=\"n2-highmem-16\", region=\"us-west1-a\"}"
    },
    {
        "instruction": "Show me the average amount of total memory used in the 5 minute window in kubernetes cluster target and org_id orgid by the container",
        "input": "",
        "output": "avg_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Tell me the sum of total memory used over the last 24 hours in the target kubernetes cluster and orgid org_id by the container",
        "input": "",
        "output": "sum_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[24h])"
    },
    {
        "instruction": "Can you show me the minimum amount of ram usage over a 1-hour window in the target kubernetes cluster and orgid org_id",
        "input": "",
        "output": "min_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h])"
    },
    {
        "instruction": "Show me the rate of change in the total container memory usage over the last 5 minutes for target cluster and orgid organization",
        "input": "",
        "output": "rate(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m])"
    },
    {
        "instruction": "Show me the difference in the total memory usage by the container between 1 hour ago and now",
        "input": "",
        "output": "delta(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h])"
    },
    {
        "instruction": "Sum of total memory usage across all hosts by the container",
        "input": "",
        "output": "sum(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "show the average of the total used memory by a container across all hosts.",
        "input": "",
        "output": "avg(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "show the maximum amount of memory used by the container across all hosts:",
        "input": "",
        "output": "max(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the minimum amount of memory used by the container across all hosts:",
        "input": "",
        "output": "min(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the standard deviation of memory used by the container across all hosts:",
        "input": "",
        "output": "stddev(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"})"
    },
    {
        "instruction": "Show the count of hosts where memory usage by the container is below a threshold of 20%",
        "input": "",
        "output": "count(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"} < 20)"
    },
    {
        "instruction": "Calculate the average total memory used by the container over a 5-minute window, aggregated by host:",
        "input": "",
        "output": "avg by (host) (avg_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[5m]))"
    },
    {
        "instruction": "Find the maximum memory used by the container over a 15-minute window, aggregated by instance_type",
        "input": "",
        "output": "max by (instance_type) (max_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[15m]))"
    },
    {
        "instruction": "Sum the amount of memory used by the container over the last hour, aggregated by host for the last hour.",
        "input": "",
        "output": "sum by (host) (sum_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[1h]))"
    },
    {
        "instruction": "Calculate the average memory used by the container over a 10-minute window, aggregated by host host and instance_type instance_type",
        "input": "",
        "output": "avg by (host, instance_type) (avg_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[10m]))"
    },
    {
        "instruction": "Find the minimum memory used by the container over the last 24 hours, aggregated by cluster_name shared:",
        "input": "",
        "output": "min by (shared) (min_over_time(container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgId\"}[24h]))"
    },
    {
        "instruction": "nan",
        "input": "",
        "output": "nan"
    },
    {
        "instruction": "Show me the average system disk read time per second for each host in the last 2 hours for the cluster name target, organization id orgid, and devices name not starting with loop",
        "input": "",
        "output": "avg by (host) (rate(system_disk_read_time{kube_cluster_name=\"target\", device!~\"loop.*\", org_id=\"orgid\"}[2h]))"
    },
    {
        "instruction": "Give me the max system disk read time per second for each host within an hour for the cluster name target, organization id orgid, and devices name starting with loop",
        "input": "",
        "output": "max by (host) (rate(system_disk_read_time{kube_cluster_name=\"target\", device=~\"loop.*\", org_id=\"orgid\"}[1h]))"
    },
    {
        "instruction": "Show me the average system disk read time per second for each host in the last 5 minutes for the cluster name target, organization id orgid, and devices name should not start with loop",
        "input": "",
        "output": "avg by (host) (rate(system_disk_read_time{kube_cluster_name=\"target\", device!~\"loop.*\", org_id=\"orgid\"}[5m]))"
    },
    {
        "instruction": "Show in bytes the total used storage volume for Persistent Volume Claims (PVCs) that have names starting with 'data-pinot-server-realtime' and belong to the cluster name 'target', namespace 'namespace' and organization id 'orgid'",
        "input": "",
        "output": "sum (kubernetes_kubelet_volume_stats_used_bytes{kube_cluster_name=\"target\",persistentvolumeclaim=\"data-pinot-server-realtime.*\", org_id=\"orgId\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Calculate the total used storage volume in bytes for Kubernetes Persistent Volume Claims (PVCs) that have names starting with 'data-pinot-server-realtime' and belong to the cluster name 'target', namespace 'namespace' and organization id 'orgid'",
        "input": "",
        "output": "sum (kubernetes_kubelet_volume_stats_used_bytes{kube_cluster_name=\"target\",persistentvolumeclaim=\"data-pinot-server-realtime.*\", org_id=\"orgId\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Show the total used storage volume in bytes for Kubernetes Persistent Volume Claims (PVCs) that have names starting with 'data-pinot-server-offline' and belong to the cluster name 'target', namespace 'namespace' and organization id 'orgid'",
        "input": "",
        "output": "sum (kubernetes_kubelet_volume_stats_used_bytes{kube_cluster_name=\"target\",persistentvolumeclaim=\"data-pinot-server-offline.*\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Calculate the total used storage volume in bytes for Kubernetes Persistent Volume Claims that have names starting with 'data-kafka' and belong to the cluster 'target', namespace 'namespace' and organization id 'orgid'",
        "input": "",
        "output": "sum (kubernetes_kubelet_volume_stats_used_bytes{kube_cluster_name=\"target\",persistentvolumeclaim=\"data-kafka.*\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Calculate the total used storage volume in bytes for PVCs that have names starting with 'data-pinot-zookeeper' and belong to the cluster name 'target', namespace 'namespace' and organization id 'orgid'",
        "input": "",
        "output": "sum (kubernetes_kubelet_volume_stats_used_bytes{kube_cluster_name=\"target\",persistentvolumeclaim=\"data-pinot-zookeeper.*\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Return the total used storage volume in bytes for Kubernetes PVCs that have names starting with 'data-pinot-controller' where the cluster name is target and organization id is orgid and namespace is namespace",
        "input": "",
        "output": "sum (kubernetes_kubelet_volume_stats_used_bytes{kube_cluster_name=\"target\",persistentvolumeclaim=\"data-pinot-controller.*\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Show me the sum of average container CPU usage per pod for the last 5 minutes in millicores",
        "input": "",
        "output": "sum by (pod_name) (avg_over_time(container_cpu_usage{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"}[5m])) / 10^6"
    },
    {
        "instruction": "Retrieve the total average CPU usage for containers per pod for the last 5 minutes in millicores",
        "input": "",
        "output": "sum by (pod_name) (avg_over_time(container_cpu_usage{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"}[5m])) / 10^6"
    },
    {
        "instruction": "Retrieve the top 5 pod names with the highest sum of container memory usage in gigabytes (GB), within the cluster 'cluster', organization ID 'orgid', and namespace as namespace.",
        "input": "",
        "output": "topk(5, sum by (pod_name) (container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"}) / 10^9)"
    },
    {
        "instruction": "Retrieve the top 10 pod names with the highest sum of container memory usage in gigabytes (GB), within the cluster 'cluster', organization ID 'orgid', and namespace as namespace.",
        "input": "",
        "output": "topk(10, sum by (pod_name) (container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"}) / 10^9)"
    },
    {
        "instruction": "Retrieve the top 5 pod names with the highest average container memory usage in gigabytes (GB), within the cluster 'cluster', organization ID 'orgid', and namespace as namespace.",
        "input": "",
        "output": "topk(5, avg by (pod_name) (container_memory_usage{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"}) / 10^9)"
    },
    {
        "instruction": "Calculate the sum of container input output read operations per pod where the cluster name is target, namespace is namespace and organization id is orgid",
        "input": "",
        "output": "sum by (pod_name) (container_io_read_operations{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Retrieve the total input output read operations for containers for each pod where the cluster name is target, namespace is namespace and organization id is orgid",
        "input": "",
        "output": "sum by (pod_name) (container_io_read_operations{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Show the sum of container input output write operations per pod where the cluster name is target, namespace is namespace and organization id is orgid",
        "input": "",
        "output": "sum by (pod_name) (container_io_write_operations{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Retrieve the total input output write operations for containers for each pod where the cluster name is target, namespace is namespace and organization id is orgid",
        "input": "",
        "output": "sum by (pod_name) (container_io_write_operations{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "Can you give me the total i/o write operations for containers for each pod where the cluster name is target, namespace is namespace and organization id is orgid",
        "input": "",
        "output": "sum by (pod_name) (container_io_write_operations{kube_cluster_name=\"target\", org_id=\"orgid\", kube_namespace=\"namespace\"})"
    },
    {
        "instruction": "which promql function is used to calculate the average value of all points in the specified interval.",
        "input": "",
        "output": "avg_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the minimum value of all points in the specified interval.",
        "input": "",
        "output": "min_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the maximum value of all points in the specified interval.",
        "input": "",
        "output": "max_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the sum of all values in the specified interval.",
        "input": "",
        "output": "sum_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the count of all values in the specified interval.",
        "input": "",
        "output": "count_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the φ-quantile (0 ≤ φ ≤ 1) of the values in the specified interval.",
        "input": "",
        "output": "quantile_over_time(scalar, range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the population standard deviation of the values in the specified interval.",
        "input": "",
        "output": "stddev_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the population standard variance of the values in the specified interval.",
        "input": "",
        "output": "stdvar_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the most recent point value in the specified interval.",
        "input": "",
        "output": "last_over_time(range-vector)"
    },
    {
        "instruction": "which promql function is used to calculate the value 1 for any series in the specified interval.",
        "input": "",
        "output": "present_over_time(range-vector)"
    },
    {
        "instruction": "list of labels used with system_mem_used",
        "input": "",
        "output": "availability_zone, host, kube_cluster_name, kfuse, org_id, project, region, instance_type"
    },
    {
        "instruction": "list all filters used with the metric system_mem_used",
        "input": "",
        "output": "availability_zone, host, kube_cluster_name, kfuse, org_id, project, region, instance_type"
    },
    {
        "instruction": "list of labels used with system_disk_read_time",
        "input": "",
        "output": "availability_zone, host, kube_cluster_name, kfuse, org_id, project, region, instance_type, device, device_name"
    },
    {
        "instruction": "list all filters used with the metric system_disk_read_time",
        "input": "",
        "output": "availability_zone, host, kube_cluster_name, kfuse, org_id, project, region, instance_type, device, device_name"
    },
    {
        "instruction": "list all labels used with kubernetes_kubelet_volume_stats_used_bytes",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by,"
    },
    {
        "instruction": "list all filters used with the metric kubernetes_kubelet_volume_stats_used_bytes",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by,"
    },
    {
        "instruction": "list all labels used with container_memory_usage",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_name, app_kubernetes_io_part_of, app_kubernetes_io_version, availability_zone, component, container_id, container_name, controller_revision_hash, display_container_name, docker_image, git_commit_sha, git_repository_url, helm_sh_chart, host, image_id, image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_cluster_name, kube_container_name, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_ownerref_name, kube_priority_class, kube_service, kube_stateful_set, org_id, persistentvolumeclaim, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name"
    },
    {
        "instruction": "list out all the filters used with container_memory_usage",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_name, app_kubernetes_io_part_of, app_kubernetes_io_version, availability_zone, component, container_id, container_name, controller_revision_hash, display_container_name, docker_image, git_commit_sha, git_repository_url, helm_sh_chart, host, image_id, image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_cluster_name, kube_container_name, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_ownerref_name, kube_priority_class, kube_service, kube_stateful_set, org_id, persistentvolumeclaim, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name"
    },
    {
        "instruction": "list all labels used with container_cpu_usage",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_name, app_kubernetes_io_part_of, app_kubernetes_io_version, availability_zone, component, container_id, container_name, controller_revision_hash, display_container_name, docker_image, git_commit_sha, git_repository_url, helm_sh_chart, host, image_id, image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_cluster_name, kube_container_name, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_ownerref_name, kube_priority_class, kube_service, kube_stateful_set, org_id, persistentvolumeclaim, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name"
    },
    {
        "instruction": "list all filters used with container_cpu_usage",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_name, app_kubernetes_io_part_of, app_kubernetes_io_version, availability_zone, component, container_id, container_name, controller_revision_hash, display_container_name, docker_image, git_commit_sha, git_repository_url, helm_sh_chart, host, image_id, image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_cluster_name, kube_container_name, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_ownerref_name, kube_priority_class, kube_service, kube_stateful_set, org_id, persistentvolumeclaim, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name"
    },
    {
        "instruction": "list all labels used with container_io_read_operations",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_part_of, container_name, controller_revision_hash, device, device_name, display_container_name, docker_image, git_commit_sha, helm_sh_chart, host, image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_priority_class, kube_service, kube_stateful_set, org_id, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name, persistentvolumeclaim"
    },
    {
        "instruction": "list all filters used with container_io_read_operations",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_part_of, container_name, controller_revision_hash, device, device_name, display_container_name, docker_image, git_commit_sha, helm_sh_chart, host, image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_priority_class, kube_service, kube_stateful_set, org_id, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name, persistentvolumeclaim"
    },
    {
        "instruction": "list all labels used with container_io_write_operations",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_part_of, container_name, controller_revision_hash, device, device_name, display_container_name, docker_image, git_commit_sha, helm_sh_chart, host,  image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_priority_class, kube_service, kube_stateful_set, org_id, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name, persistentvolumeclaim"
    },
    {
        "instruction": "list all filters used with container_io_write_operations",
        "input": "",
        "output": "app, app_kubernetes_io_component, app_kubernetes_io_instance, app_kubernetes_io_managed_by, app_kubernetes_io_part_of, container_name, controller_revision_hash, device, device_name, display_container_name, docker_image, git_commit_sha, helm_sh_chart, host,  image_name, image_tag, instance_type, kfuse, kube_app_component, kube_app_instance, kube_app_managed_by, kube_app_name, kube_app_part_of, kube_app_version, kube_daemon_set, kube_deployment, kube_namespace, kube_ownerref_kind, kube_priority_class, kube_service, kube_stateful_set, org_id, pod_name, pod_phase, project, region, release, runtime, short_image, statefulset_kubernetes_io_pod_name, persistentvolumeclaim"
    },
    {
        "instruction": "which kubernetes metric tracks the amount of RAM in use.",
        "input": "",
        "output": "system_mem_used"
    },
    {
        "instruction": "which metric is used to track the amount of memory being used in bytes",
        "input": "",
        "output": "system_mem_used"
    },
    {
        "instruction": "which metric can be used to track the time used for reading each device in milliseconds",
        "input": "",
        "output": "system_disk_read_time"
    },
    {
        "instruction": "which kubernetes metric tracks the time in ms spent reading per device.",
        "input": "",
        "output": "system_disk_read_time"
    },
    {
        "instruction": "which kubernetes metric tracks the container total CPU Usage",
        "input": "",
        "output": "container_cpu_usage"
    },
    {
        "instruction": "which metric can be used to get the total usage of CPU for a container",
        "input": "",
        "output": "container_cpu_usage"
    },
    {
        "instruction": "which metric is used to track the total memory used by the container",
        "input": "",
        "output": "container_memory_usage"
    },
    {
        "instruction": "which kubernetes metric tracks the container total memory usage",
        "input": "",
        "output": "container_memory_usage"
    },
    {
        "instruction": "which kubernetes metric tracks the number of read operations done by this container",
        "input": "",
        "output": "container_io_read_operations"
    },
    {
        "instruction": "which metric can be used for getting the number of read operations by this container",
        "input": "",
        "output": "container_io_read_operations"
    },
    {
        "instruction": "which metric can be used for getting the number of write operations by this container",
        "input": "",
        "output": "container_io_write_operations"
    },
    {
        "instruction": "which kubernetes metric tracks the number of write operations done by this container",
        "input": "",
        "output": "container_io_write_operations"
    },
    {
        "instruction": "which kubernetes metric shows whether the containers readiness check succeeded?",
        "input": "",
        "output": "kubernetes_state_container_ready"
    },
    {
        "instruction": "which kubernetes metric shows whether the container is in the ready state or not?",
        "input": "",
        "output": "kubernetes_state_container_ready"
    },
    {
        "instruction": "which kubernetes metric shows whether the container is currently in running state?",
        "input": "",
        "output": "kubernetes_state_container_running"
    },
    {
        "instruction": "which kubernetes metric tracks whether the container is currently in terminated state?",
        "input": "",
        "output": "kubernetes_state_container_terminated"
    },
    {
        "instruction": "which kubernetes metric count the containers currently reporting in terminated state with the reason as a tag?",
        "input": "",
        "output": "kubernetes_state_container_status_report_count_terminated"
    },
    {
        "instruction": "which kubernetes metric shows whether the container is currently in waiting state?",
        "input": "",
        "output": "kubernetes_state_container_waiting"
    },
    {
        "instruction": "which kubernetes metric counts the number of containers currently reporting in the waiting state with the reason as a tag?",
        "input": "",
        "output": "kubernetes_state_container_status_report_count_waiting"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of requested gpu devices by a container",
        "input": "",
        "output": "kubernetes_state_container_gpu_request"
    },
    {
        "instruction": "which kubernetes metrics is used to track the limit on the number of gpu devices to be used by a container?",
        "input": "",
        "output": "kubernetes_state_container_gpu_limit"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of restarts per container?",
        "input": "",
        "output": "kubernetes_state_container_restarts"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of requested cpu cores by a container",
        "input": "",
        "output": "kubernetes_state_container_cpu_requested"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of requested memory bytes by a container",
        "input": "",
        "output": "kubernetes_state_container_memory_requested"
    },
    {
        "instruction": "which kubernetes metrics is used to track the limit on cpu cores to be used by a container",
        "input": "",
        "output": "kubernetes_state_container_cpu_limit"
    },
    {
        "instruction": "which kubernetes metrics is used to track the limit on memory to be used by a container?",
        "input": "",
        "output": "kubernetes_state_container_memory_limit"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of containers that were previously terminated",
        "input": "",
        "output": "kubernetes_containers_last_state_terminated"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of running containers",
        "input": "",
        "output": "kubernetes_containers_running"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of times  the container has been restarted",
        "input": "",
        "output": "kubernetes_containers_restarts"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of currently terminated containers",
        "input": "",
        "output": "kubernetes_containers_state_terminated"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of currently waiting containers",
        "input": "",
        "output": "kubernetes_containers_state_waiting"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of nodes running at least one daemon pod which are supposed to run it?",
        "input": "",
        "output": "kubernetes_state_daemonset_scheduled"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of nodes running a daemon pod but are not supposed to run it?",
        "input": "",
        "output": "kubernetes_state_daemonset_misscheduled"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of nodes that should be running the daemon pod",
        "input": "",
        "output": "kubernetes_state_daemonset_desired"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of nodes that should be running daemon pod and have one or more running and ready ?",
        "input": "",
        "output": "kubernetes_state_daemonset_ready"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of nodes that run updated daemon pod spec?",
        "input": "",
        "output": "kubernetes_state_daemonset_updated"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of deployments",
        "input": "",
        "output": "kubernetes_state_deployment_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of available replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_available"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of unavailable replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_unavailable"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of updated replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_updated"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of desired replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_desired"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of deployments that are paused?",
        "input": "",
        "output": "kubernetes_state_deployment_paused"
    },
    {
        "instruction": "which kubernetes metrics is used to find the maximum number of unavailable replicas during a rolling update?",
        "input": "",
        "output": "kubernetes_state_deployment_rollingupdate_max_unavailable"
    },
    {
        "instruction": "which kubernetes metrics is used to track the returns response in bytes.",
        "input": "",
        "output": "kubedns_response_size_bytes_sum"
    },
    {
        "instruction": "which kubernetes metrics is used to get the number of responses on which kubedns.response_size.bytes.sum metric is evaluated?",
        "input": "",
        "output": "kubedns_response_size_bytes_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Time (in seconds) each request took to resolve.",
        "input": "",
        "output": "kubedns_request_duration_seconds_sum"
    },
    {
        "instruction": "which kubernetes metrics is used to get the number of requests on which kubedns.request_duration.seconds.sum metric is evaluated?",
        "input": "",
        "output": "kubedns_request_duration_seconds_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Total number of DNS requests made.",
        "input": "",
        "output": "kubedns_request_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Instant number of DNS requests made.",
        "input": "",
        "output": "kubedns_request_count_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of DNS requests resulting in an error.",
        "input": "",
        "output": "kubedns_error_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Instant number of DNS requests made resulting in an error.",
        "input": "",
        "output": "kubedns_error_count_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of DNS requests resulting in a cache miss.",
        "input": "",
        "output": "kubedns_cachemiss_count"
    },
    {
        "instruction": "Instant number of DNS requests made resulting in a cache miss.",
        "input": "",
        "output": "kubedns_cachemiss_count_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of addresses available in endpoint",
        "input": "",
        "output": "kubernetes_state_endpoint_address_available"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of addresses not ready in endpoint",
        "input": "",
        "output": "kubernetes_state_endpoint_address_not_ready"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Unix creation timestamp",
        "input": "",
        "output": "kubernetes_state_endpoint_created"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of jobs",
        "input": "",
        "output": "kubernetes_state_job_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Observed number of failed pods in a job",
        "input": "",
        "output": "kubernetes_state_job_failed"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Observed number of succeeded pods in a job",
        "input": "",
        "output": "kubernetes_state_job_succeeded"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of namespaces",
        "input": "",
        "output": "kubernetes_state_namespace_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of nodes",
        "input": "",
        "output": "kubernetes_state_node_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the total CPU resources of node",
        "input": "",
        "output": "kubernetes_state_node_cpu_capacity"
    },
    {
        "instruction": "which kubernetes metrics is used to track the total memory resources of the node",
        "input": "",
        "output": "kubernetes_state_node_memory_capacity"
    },
    {
        "instruction": "which kubernetes metrics is used to track the total pod resources of the node",
        "input": "",
        "output": "kubernetes_state_node_pods_capacity"
    },
    {
        "instruction": "which kubernetes metrics is used to track the GPU resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_gpu_cards_allocatable"
    },
    {
        "instruction": "which kubernetes metrics is used to track the total GPU resources of the node",
        "input": "",
        "output": "kubernetes_state_node_gpu_cards_capacity"
    },
    {
        "instruction": "which kubernetes metrics is used to track the CPU resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_cpu_allocatable"
    },
    {
        "instruction": "which kubernetes metrics is used to track the memory resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_memory_allocatable"
    },
    {
        "instruction": "which kubernetes metrics is used to track the pod resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_pods_allocatable"
    },
    {
        "instruction": "Which kubernetes metric is use to track whether the node can schedule new pods?",
        "input": "",
        "output": "kubernetes_state_node_status"
    },
    {
        "instruction": "Which kubernetes metric is use to sum by `condition` and `status` to get number of nodes in a given condition?",
        "input": "",
        "output": "kubernetes_state_nodes_by_condition"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Container cpu load average over the last 10 seconds?",
        "input": "",
        "output": "kubernetes_cpu_load_10s_avg"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of cores used for system time",
        "input": "",
        "output": "kubernetes_cpu_system_total"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of cores used for user time",
        "input": "",
        "output": "kubernetes_cpu_user_total"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of elapsed enforcement period intervals",
        "input": "",
        "output": "kubernetes_cpu_cfs_periods"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of throttled period intervals",
        "input": "",
        "output": "kubernetes_cpu_cfs_throttled_periods"
    },
    {
        "instruction": "Total time duration which kubernetes metrics is used to track the container has been throttled",
        "input": "",
        "output": "kubernetes_cpu_cfs_throttled_seconds"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of cores used",
        "input": "",
        "output": "kubernetes_cpu_usage_total"
    },
    {
        "instruction": "which kubernetes metrics is used to track the limit of cpu cores set",
        "input": "",
        "output": "kubernetes_cpu_limits"
    },
    {
        "instruction": "which kubernetes metrics is used to track the requested cpu cores",
        "input": "",
        "output": "kubernetes_cpu_requests"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of disk used",
        "input": "",
        "output": "kubernetes_filesystem_usage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the percentage of disk used",
        "input": "",
        "output": "kubernetes_filesystem_usage_pct"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of bytes read from which kubernetes metrics is used to track the disk",
        "input": "",
        "output": "kubernetes_io_read_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of bytes written to which kubernetes metrics is used to track the disk",
        "input": "",
        "output": "kubernetes_io_write_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the limit of memory set",
        "input": "",
        "output": "kubernetes_memory_limits"
    },
    {
        "instruction": "which kubernetes metrics is used to track the limit of swap space set",
        "input": "",
        "output": "kubernetes_memory_sw_limit"
    },
    {
        "instruction": "which kubernetes metrics is used to track the requested memory",
        "input": "",
        "output": "kubernetes_memory_requests"
    },
    {
        "instruction": "Which kubernetes metric is use to track the current memory usage in bytes including all memory regardless of when it was accessed?",
        "input": "",
        "output": "kubernetes_memory_usage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Current working set in bytes - this is what OOM killer is watching for",
        "input": "",
        "output": "kubernetes_memory_working_set"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of memory that is being used to cache data from disk (e.g. memory contents that can be associated precisely with a block on a block device)",
        "input": "",
        "output": "kubernetes_memory_cache"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Size of RSS in bytes",
        "input": "",
        "output": "kubernetes_memory_rss"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of swap currently used by by processes in this cgroup",
        "input": "",
        "output": "kubernetes_memory_swap"
    },
    {
        "instruction": "which kubernetes metrics is used to track the percentage of memory used",
        "input": "",
        "output": "kubernetes_memory_usage_pct"
    },
    {
        "instruction": "which kubernetes metrics is used to track the percentage of swap space used",
        "input": "",
        "output": "kubernetes_memory_sw_in_use"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of bytes per second received",
        "input": "",
        "output": "kubernetes_network_rx_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of rx packets dropped per second",
        "input": "",
        "output": "kubernetes_network_rx_dropped"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of rx errors per second",
        "input": "",
        "output": "kubernetes_network_rx_errors"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of bytes per second transmitted",
        "input": "",
        "output": "kubernetes_network_tx_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of tx packets dropped per second",
        "input": "",
        "output": "kubernetes_network_tx_dropped"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of tx errors per second",
        "input": "",
        "output": "kubernetes_network_tx_errors"
    },
    {
        "instruction": "which kubernetes metrics is used to track the amount of disk space container uses",
        "input": "",
        "output": "kubernetes_diskio_io_service_bytes_stats_total"
    },
    {
        "instruction": "which kubernetes metrics is used to track the count of remaining lifetime on the certificate used to authenticate a request",
        "input": "",
        "output": "kubernetes_apiserver_certificate_expiration_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the sum of remaining lifetime on certificate used to authenticate a request",
        "input": "",
        "output": "kubernetes_apiserver_certificate_expiration_sum"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of HTTP requests",
        "input": "",
        "output": "kubernetes_rest_client_requests"
    },
    {
        "instruction": "which kubernetes metrics is used to track the count of request latency in seconds broken down by verb and URL",
        "input": "",
        "output": "kubernetes_rest_client_latency_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the sum of request latency in seconds broken down by verb and URL",
        "input": "",
        "output": "kubernetes_rest_client_latency_sum"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of runtime operations",
        "input": "",
        "output": "kubernetes_kubelet_runtime_operations"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of runtime operations errors",
        "input": "",
        "output": "kubernetes_kubelet_runtime_errors"
    },
    {
        "instruction": "which kubernetes metrics is used to track the sum of latency in microseconds of network plugin operations",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_sum"
    },
    {
        "instruction": "which kubernetes metrics is used to track the count of network plugin operations by latency",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the quantiles of network plugin operations by latency",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_quantile"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of available bytes to track the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the capacity in bytes of the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of used bytes in volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the maximum number of inodes in volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of free inodes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of used inodes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Ephemeral storage usage of the pod?",
        "input": "",
        "output": "kubernetes_ephemeral_storage_usage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of cores used by kubelet",
        "input": "",
        "output": "kubernetes_kubelet_cpu_usage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Size of kubelet RSS in bytes",
        "input": "",
        "output": "kubernetes_kubelet_memory_rss"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of cores used by the runtime",
        "input": "",
        "output": "kubernetes_runtime_cpu_usage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Size of runtime RSS in bytes",
        "input": "",
        "output": "kubernetes_runtime_memory_rss"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Bytes used by container's logs on filesystem (requires kubernetes 1.14+)",
        "input": "",
        "output": "kubernetes_kubelet_container_log_filesystem_used_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the phase persistent volume claim is currently in",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_status"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Storage space request for a given pvc",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_request_storage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Number of persistent volumes to sum by phase and storageclass",
        "input": "",
        "output": "kubernetes_state_persistentvolumes_by_phase"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of available bytes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the capacity in bytes of the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of used bytes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the maximum number of inodes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of free inodes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of used inodes in the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "In association with the `condition` tag, which kubernetes metrics is used to track the pod whihc is ready to serve requests, e.g. `condition:true` keeps the pods that are in a ready state",
        "input": "",
        "output": "kubernetes_state_pod_ready"
    },
    {
        "instruction": "Report which kubernetes metrics is used to track the status of scheduling process for pod with its tags",
        "input": "",
        "output": "kubernetes_state_pod_scheduled"
    },
    {
        "instruction": "which kubernetes metrics is used to report PODs that Kube scheduler cannot schedule on any node",
        "input": "",
        "output": "kubernetes_state_pod_unschedulable"
    },
    {
        "instruction": "To sum by `phase` to get number of pods in a given phase, and `namespace` to break this down by namespace",
        "input": "",
        "output": "kubernetes_state_pod_status_phase"
    },
    {
        "instruction": "which kubernetes metrics is used to track number of running pods in a cluster",
        "input": "",
        "output": "kubernetes_pods_running"
    },
    {
        "instruction": "which kubernetes metrics is used to track number of expired pods in a cluster",
        "input": "",
        "output": "kubernetes_pods_expired"
    },
    {
        "instruction": "which kubernetes metrics is used to track the phase the persistent volume claim is currently in?",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_status"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Storage space request for a given pvc",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_request_storage"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of replicasets",
        "input": "",
        "output": "kubernetes_state_replicaset_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of replicas per ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of fully labeled replicas per ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_fully_labeled_replicas"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of ready replicas per ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas_ready"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of desired pods for a ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas_desired"
    },
    {
        "instruction": "which kubernetes metrics is used to track the Sum by namespace and type to count active services",
        "input": "",
        "output": "kubernetes_state_service_count"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of replicas per statefulset",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of desired replicas per statefulset",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_desired"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of current replicas per StatefulSet",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_current"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of ready replicas per StatefulSet",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_ready"
    },
    {
        "instruction": "which kubernetes metrics is used to track the number of updated replicas per StatefulSet",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_updated"
    },
    {
        "instruction": "Whether the containers readiness check succeeded",
        "input": "",
        "output": "kubernetes_state_container_ready"
    },
    {
        "instruction": "Whether the container is currently in running state",
        "input": "",
        "output": "kubernetes_state_container_running"
    },
    {
        "instruction": "Whether the container is currently in terminated state",
        "input": "",
        "output": "kubernetes_state_container_terminated"
    },
    {
        "instruction": "Count of the containers currently reporting a in terminated state with the reason as a tag",
        "input": "",
        "output": "kubernetes_state_container_status_report_count_terminated"
    },
    {
        "instruction": "Whether the container is currently in waiting state",
        "input": "",
        "output": "kubernetes_state_container_waiting"
    },
    {
        "instruction": "Count of the containers currently reporting a in waiting state with the reason as a tag",
        "input": "",
        "output": "kubernetes_state_container_status_report_count_waiting"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of requested gpu devices by a container",
        "input": "",
        "output": "kubernetes_state_container_gpu_request"
    },
    {
        "instruction": "show me the kubernetes metric to get the limit on gpu devices to be used by a container",
        "input": "",
        "output": "kubernetes_state_container_gpu_limit"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of restarts per container",
        "input": "",
        "output": "kubernetes_state_container_restarts"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of requested cpu cores by a container",
        "input": "",
        "output": "kubernetes_state_container_cpu_requested"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of requested memory bytes by a container",
        "input": "",
        "output": "kubernetes_state_container_memory_requested"
    },
    {
        "instruction": "show me the kubernetes metric to get the limit on cpu cores to be used by a container",
        "input": "",
        "output": "kubernetes_state_container_cpu_limit"
    },
    {
        "instruction": "show me the kubernetes metric to get the limit on memory to be used by a container",
        "input": "",
        "output": "kubernetes_state_container_memory_limit"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of containers that were previously terminated",
        "input": "",
        "output": "kubernetes_containers_last_state_terminated"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of running containers",
        "input": "",
        "output": "kubernetes_containers_running"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of times show me the kubernetes metric to get the container has been restarted",
        "input": "",
        "output": "kubernetes_containers_restarts"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of currently terminated containers",
        "input": "",
        "output": "kubernetes_containers_state_terminated"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of currently waiting containers",
        "input": "",
        "output": "kubernetes_containers_state_waiting"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of nodes running at least one daemon pod and that are supposed to",
        "input": "",
        "output": "kubernetes_state_daemonset_scheduled"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of nodes running a daemon pod but are not supposed to",
        "input": "",
        "output": "kubernetes_state_daemonset_misscheduled"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of nodes that should be running show me the kubernetes metric to get the daemon pod",
        "input": "",
        "output": "kubernetes_state_daemonset_desired"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of nodes that should be running show me the kubernetes metric to get the daemon pod and have one or more running and ready",
        "input": "",
        "output": "kubernetes_state_daemonset_ready"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of nodes that run show me the kubernetes metric to get the updated daemon pod spec",
        "input": "",
        "output": "kubernetes_state_daemonset_updated"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of deployments",
        "input": "",
        "output": "kubernetes_state_deployment_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of available replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_available"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of unavailable replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_unavailable"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of updated replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_updated"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of desired replicas per deployment",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_desired"
    },
    {
        "instruction": "Wheshow me the kubernetes metric to get ther a deployment is paused",
        "input": "",
        "output": "kubernetes_state_deployment_paused"
    },
    {
        "instruction": "Maximum number of unavailable replicas during a rolling update",
        "input": "",
        "output": "kubernetes_state_deployment_rollingupdate_max_unavailable"
    },
    {
        "instruction": "Size of show me the kubernetes metric to get the returns response in bytes.",
        "input": "",
        "output": "kubedns_response_size_bytes_sum"
    },
    {
        "instruction": "Number of responses on which show me the kubernetes metric to get the kubedns.response_size.bytes.sum metric is evaluated.",
        "input": "",
        "output": "kubedns_response_size_bytes_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Time (in seconds) each request took to resolve.",
        "input": "",
        "output": "kubedns_request_duration_seconds_sum"
    },
    {
        "instruction": "Number of requests on which show me the kubernetes metric to get the kubedns.request_duration.seconds.sum metric is evaluated.",
        "input": "",
        "output": "kubedns_request_duration_seconds_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Total number of DNS requests made.",
        "input": "",
        "output": "kubedns_request_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Instant number of DNS requests made.",
        "input": "",
        "output": "kubedns_request_count_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Number of DNS requests resulting in an error.",
        "input": "",
        "output": "kubedns_error_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Instant number of DNS requests made resulting in an error.",
        "input": "",
        "output": "kubedns_error_count_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Number of DNS requests resulting in a cache miss.",
        "input": "",
        "output": "kubedns_cachemiss_count"
    },
    {
        "instruction": "Instant number of DNS requests made resulting in a cache miss.",
        "input": "",
        "output": "kubedns_cachemiss_count_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Number of addresses available in endpoint",
        "input": "",
        "output": "kubernetes_state_endpoint_address_available"
    },
    {
        "instruction": "show me the kubernetes metric to get the Number of addresses not ready in endpoint",
        "input": "",
        "output": "kubernetes_state_endpoint_address_not_ready"
    },
    {
        "instruction": "show me the kubernetes metric to get the Unix creation timestamp",
        "input": "",
        "output": "kubernetes_state_endpoint_created"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of jobs",
        "input": "",
        "output": "kubernetes_state_job_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the Observed number of failed pods in a job",
        "input": "",
        "output": "kubernetes_state_job_failed"
    },
    {
        "instruction": "show me the kubernetes metric to get the Observed number of succeeded pods in a job",
        "input": "",
        "output": "kubernetes_state_job_succeeded"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of namespaces",
        "input": "",
        "output": "kubernetes_state_namespace_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of nodes",
        "input": "",
        "output": "kubernetes_state_node_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the total CPU resources of show me the kubernetes metric to get the node",
        "input": "",
        "output": "kubernetes_state_node_cpu_capacity"
    },
    {
        "instruction": "show me the kubernetes metric to get the total memory resources of show me the kubernetes metric to get the node",
        "input": "",
        "output": "kubernetes_state_node_memory_capacity"
    },
    {
        "instruction": "show me the kubernetes metric to get the total pod resources of show me the kubernetes metric to get the node",
        "input": "",
        "output": "kubernetes_state_node_pods_capacity"
    },
    {
        "instruction": "show me the kubernetes metric to get the GPU resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_gpu_cards_allocatable"
    },
    {
        "instruction": "show me the kubernetes metric to get the total GPU resources of show me the kubernetes metric to get the node",
        "input": "",
        "output": "kubernetes_state_node_gpu_cards_capacity"
    },
    {
        "instruction": "show me the kubernetes metric to get the CPU resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_cpu_allocatable"
    },
    {
        "instruction": "show me the kubernetes metric to get the memory resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_memory_allocatable"
    },
    {
        "instruction": "show me the kubernetes metric to get the pod resources of a node that are available for scheduling",
        "input": "",
        "output": "kubernetes_state_node_pods_allocatable"
    },
    {
        "instruction": "Submitted with a value of 1 for each node and tagged eishow me the kubernetes metric to get ther 'status:schedulable' or 'status:unschedulable'; Sum this metric by eishow me the kubernetes metric to get ther status to get show me the kubernetes metric to get the number of nodes in that status.",
        "input": "",
        "output": "kubernetes_state_node_status"
    },
    {
        "instruction": "To sum by `condition` and `status` to get number of nodes in a given condition.",
        "input": "",
        "output": "kubernetes_state_nodes_by_condition"
    },
    {
        "instruction": "Container cpu load average over show me the kubernetes metric to get the last 10 seconds",
        "input": "",
        "output": "kubernetes_cpu_load_10s_avg"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of cores used for system time",
        "input": "",
        "output": "kubernetes_cpu_system_total"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of cores used for user time",
        "input": "",
        "output": "kubernetes_cpu_user_total"
    },
    {
        "instruction": "show me the kubernetes metric to get the Number of elapsed enforcement period intervals",
        "input": "",
        "output": "kubernetes_cpu_cfs_periods"
    },
    {
        "instruction": "show me the kubernetes metric to get the Number of throttled period intervals",
        "input": "",
        "output": "kubernetes_cpu_cfs_throttled_periods"
    },
    {
        "instruction": "Total time duration show me the kubernetes metric to get the container has been throttled",
        "input": "",
        "output": "kubernetes_cpu_cfs_throttled_seconds"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of cores in this machine (available until kubernetes v1.18)",
        "input": "",
        "output": "kubernetes_cpu_capacity"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of cores used",
        "input": "",
        "output": "kubernetes_cpu_usage_total"
    },
    {
        "instruction": "show me the kubernetes metric to get the limit of cpu cores set",
        "input": "",
        "output": "kubernetes_cpu_limits"
    },
    {
        "instruction": "show me the kubernetes metric to get the requested cpu cores",
        "input": "",
        "output": "kubernetes_cpu_requests"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of disk used",
        "input": "",
        "output": "kubernetes_filesystem_usage"
    },
    {
        "instruction": "show me the kubernetes metric to get the percentage of disk used",
        "input": "",
        "output": "kubernetes_filesystem_usage_pct"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of bytes read from show me the kubernetes metric to get the disk",
        "input": "",
        "output": "kubernetes_io_read_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of bytes written to show me the kubernetes metric to get the disk",
        "input": "",
        "output": "kubernetes_io_write_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of memory (in bytes) in this machine (available until kubernetes v1.18)",
        "input": "",
        "output": "kubernetes_memory_capacity"
    },
    {
        "instruction": "show me the kubernetes metric to get the limit of memory set",
        "input": "",
        "output": "kubernetes_memory_limits"
    },
    {
        "instruction": "show me the kubernetes metric to get the limit of swap space set",
        "input": "",
        "output": "kubernetes_memory_sw_limit"
    },
    {
        "instruction": "show me the kubernetes metric to get the requested memory",
        "input": "",
        "output": "kubernetes_memory_requests"
    },
    {
        "instruction": "Current memory usage in bytes including all memory regardless of when it was accessed",
        "input": "",
        "output": "kubernetes_memory_usage"
    },
    {
        "instruction": "Current working set in bytes - this is what show me the kubernetes metric to get the OOM killer is watching for",
        "input": "",
        "output": "kubernetes_memory_working_set"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of memory that is being used to cache data from disk (e.g. memory contents that can be associated precisely with a block on a block device)",
        "input": "",
        "output": "kubernetes_memory_cache"
    },
    {
        "instruction": "show me the kubernetes metric to get the Size of RSS in bytes",
        "input": "",
        "output": "kubernetes_memory_rss"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of swap currently used by by processes in this cgroup",
        "input": "",
        "output": "kubernetes_memory_swap"
    },
    {
        "instruction": "show me the kubernetes metric to get the percentage of memory used",
        "input": "",
        "output": "kubernetes_memory_usage_pct"
    },
    {
        "instruction": "show me the kubernetes metric to get the percentage of swap space used",
        "input": "",
        "output": "kubernetes_memory_sw_in_use"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of bytes per second received",
        "input": "",
        "output": "kubernetes_network_rx_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of rx packets dropped per second",
        "input": "",
        "output": "kubernetes_network_rx_dropped"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of rx errors per second",
        "input": "",
        "output": "kubernetes_network_rx_errors"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of bytes per second transmitted",
        "input": "",
        "output": "kubernetes_network_tx_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of tx packets dropped per second",
        "input": "",
        "output": "kubernetes_network_tx_dropped"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of tx errors per second",
        "input": "",
        "output": "kubernetes_network_tx_errors"
    },
    {
        "instruction": "show me the kubernetes metric to get the amount of disk space show me the kubernetes metric to get the container uses",
        "input": "",
        "output": "kubernetes_diskio_io_service_bytes_stats_total"
    },
    {
        "instruction": "show me the kubernetes metric to get the count of remaining lifetime on show me the kubernetes metric to get the certificate used to aushow me the kubernetes metric to get thenticate a request",
        "input": "",
        "output": "kubernetes_apiserver_certificate_expiration_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the sum of remaining lifetime on show me the kubernetes metric to get the certificate used to aushow me the kubernetes metric to get thenticate a request",
        "input": "",
        "output": "kubernetes_apiserver_certificate_expiration_sum"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of HTTP requests",
        "input": "",
        "output": "kubernetes_rest_client_requests"
    },
    {
        "instruction": "show me the kubernetes metric to get the count of request latency in seconds broken down by verb and URL",
        "input": "",
        "output": "kubernetes_rest_client_latency_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the sum of request latency in seconds broken down by verb and URL",
        "input": "",
        "output": "kubernetes_rest_client_latency_sum"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of runtime operations",
        "input": "",
        "output": "kubernetes_kubelet_runtime_operations"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of runtime operations errors",
        "input": "",
        "output": "kubernetes_kubelet_runtime_errors"
    },
    {
        "instruction": "show me the kubernetes metric to get the sum of latency in microseconds of network plugin operations",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_sum"
    },
    {
        "instruction": "show me the kubernetes metric to get the count of network plugin operations by latency",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the quantiles of network plugin operations by latency",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_quantile"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of runtime operations",
        "input": "",
        "output": "kubernetes_kubelet_runtime_operations"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of runtime operations errors",
        "input": "",
        "output": "kubernetes_kubelet_runtime_errors"
    },
    {
        "instruction": "show me the kubernetes metric to get the sum of latency in microseconds of network plugin operations",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_sum"
    },
    {
        "instruction": "show me the kubernetes metric to get the count of network plugin operations by latency",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the quantiles of network plugin operations by latency",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_quantile"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of available bytes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the capacity in bytes of show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of used bytes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the maximum number of inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of free inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of used inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "Ephemeral storage limit of show me the kubernetes metric to get the container (requires kubernetes v1.8+)",
        "input": "",
        "output": "kubernetes_ephemeral_storage_limits"
    },
    {
        "instruction": "Ephemeral storage request of show me the kubernetes metric to get the container (requires kubernetes v1.8+)",
        "input": "",
        "output": "kubernetes_ephemeral_storage_requests"
    },
    {
        "instruction": "Ephemeral storage usage of show me the kubernetes metric to get the POD",
        "input": "",
        "output": "kubernetes_ephemeral_storage_usage"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of pods that have been evicted from show me the kubernetes metric to get the kubelet (ALPHA in kubernetes v1.16)",
        "input": "",
        "output": "kubernetes_kubelet_evictions"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of cores used by kubelet",
        "input": "",
        "output": "kubernetes_kubelet_cpu_usage"
    },
    {
        "instruction": "show me the kubernetes metric to get the Size of kubelet RSS in bytes",
        "input": "",
        "output": "kubernetes_kubelet_memory_rss"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of cores used by show me the kubernetes metric to get the runtime",
        "input": "",
        "output": "kubernetes_runtime_cpu_usage"
    },
    {
        "instruction": "show me the kubernetes metric to get the Size of runtime RSS in bytes",
        "input": "",
        "output": "kubernetes_runtime_memory_rss"
    },
    {
        "instruction": "Bytes used by show me the kubernetes metric to get the container's logs on show me the kubernetes metric to get the filesystem (requires kubernetes 1.14+)",
        "input": "",
        "output": "kubernetes_kubelet_container_log_filesystem_used_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the phase show me the kubernetes metric to get the persistent volume claim is currently in",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_status"
    },
    {
        "instruction": "show me the kubernetes metric to get the Storage space request for a given pvc",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_request_storage"
    },
    {
        "instruction": "Number of persistent volumes to sum by phase and storageclass",
        "input": "",
        "output": "kubernetes_state_persistentvolumes_by_phase"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of available bytes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the capacity in bytes of show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of used bytes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the maximum number of inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of free inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of used inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of available bytes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the capacity in bytes of show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of used bytes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "show me the kubernetes metric to get the maximum number of inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of free inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of used inodes in show me the kubernetes metric to get the volume",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "In association with show me the kubernetes metric to get the `condition` tag, wheshow me the kubernetes metric to get ther show me the kubernetes metric to get the pod is ready to serve requests, e.g. `condition:true` keeps show me the kubernetes metric to get the pods that are in a ready state",
        "input": "",
        "output": "kubernetes_state_pod_ready"
    },
    {
        "instruction": "Reports show me the kubernetes metric to get the status of show me the kubernetes metric to get the scheduling process for show me the kubernetes metric to get the pod with its tags",
        "input": "",
        "output": "kubernetes_state_pod_scheduled"
    },
    {
        "instruction": "which kubernetes metrics is used to report PODs that Kube scheduler cannot schedule on any node",
        "input": "",
        "output": "kubernetes_state_pod_unschedulable"
    },
    {
        "instruction": "To sum by `phase` to get number of pods in a given phase, and `namespace` to break this down by namespace",
        "input": "",
        "output": "kubernetes_state_pod_status_phase"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of running pods in a cluster",
        "input": "",
        "output": "kubernetes_pods_running"
    },
    {
        "instruction": "show me the kubernetes metric to get show me the kubernetes metric to get the number of expired pods in a cluster",
        "input": "",
        "output": "kubernetes_pods_expired"
    },
    {
        "instruction": "show me the kubernetes metric to get show me the kubernetes metric to get the phase show me the kubernetes metric to get the persistent volume claim is currently in?",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_status"
    },
    {
        "instruction": "show me the kubernetes metric to get the Storage space request for a given pvc",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_request_storage"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of replicasets",
        "input": "",
        "output": "kubernetes_state_replicaset_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of replicas per ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of fully labeled replicas per ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_fully_labeled_replicas"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of ready replicas per ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas_ready"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of desired pods for a ReplicaSet",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas_desired"
    },
    {
        "instruction": "show me the kubernetes metric to get the Sum by namespace and type to count active services",
        "input": "",
        "output": "kubernetes_state_service_count"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of replicas per statefulset",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of desired replicas per statefulset",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_desired"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of current replicas per StatefulSet",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_current"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of ready replicas per StatefulSet",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_ready"
    },
    {
        "instruction": "show me the kubernetes metric to get the number of updated replicas per StatefulSet",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_updated"
    },
    {
        "instruction": "Which Kubernetes metric indicates whether the container is in a ready state?",
        "input": "",
        "output": "kubernetes_state_container_ready"
    },
    {
        "instruction": "Which Kubernetes metric shows the current running state of the container?",
        "input": "",
        "output": "kubernetes_state_container_running"
    },
    {
        "instruction": "Which Kubernetes metric tracks whether the container is in a terminated state?",
        "input": "",
        "output": "kubernetes_state_container_terminated"
    },
    {
        "instruction": "Which Kubernetes metric counts the number of containers reporting in a terminated state with the reason as a tag?",
        "input": "",
        "output": "kubernetes_state_container_status_report_count_terminated"
    },
    {
        "instruction": "Which Kubernetes metric indicates whether the container is currently in a waiting state?",
        "input": "",
        "output": "kubernetes_state_container_waiting"
    },
    {
        "instruction": "Which Kubernetes metric counts the number of containers currently in a waiting state with the reason as a tag?",
        "input": "",
        "output": "kubernetes_state_container_status_report_count_waiting"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of GPU devices requested by a container?",
        "input": "",
        "output": "kubernetes_state_container_gpu_request"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the limit on the number of GPU devices to be used by a container?",
        "input": "",
        "output": "kubernetes_state_container_gpu_limit"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of restarts per container?",
        "input": "",
        "output": "kubernetes_state_container_restarts"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of CPU cores requested by a container?",
        "input": "",
        "output": "kubernetes_state_container_cpu_requested"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of memory bytes requested by a container?",
        "input": "",
        "output": "kubernetes_state_container_memory_requested"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the limit on CPU cores to be used by a container?",
        "input": "",
        "output": "kubernetes_state_container_cpu_limit"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the limit on memory to be used by a container?",
        "input": "",
        "output": "kubernetes_state_container_memory_limit"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of containers that were previously terminated?",
        "input": "",
        "output": "kubernetes_containers_last_state_terminated"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of currently running containers?",
        "input": "",
        "output": "kubernetes_containers_running"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of times the container has been restarted?",
        "input": "",
        "output": "kubernetes_containers_restarts"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of currently terminated containers?",
        "input": "",
        "output": "kubernetes_containers_state_terminated"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of currently waiting containers?",
        "input": "",
        "output": "kubernetes_containers_state_waiting"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of nodes running at least one daemon pod that is supposed to run?",
        "input": "",
        "output": "kubernetes_state_daemonset_scheduled"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of nodes running a daemon pod that they are not supposed to run?",
        "input": "",
        "output": "kubernetes_state_daemonset_misscheduled"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of nodes that should be running the daemon pod?",
        "input": "",
        "output": "kubernetes_state_daemonset_desired"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of nodes that should be running a daemon pod and have one or more running and ready?",
        "input": "",
        "output": "kubernetes_state_daemonset_ready"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of nodes that have the updated daemon pod spec?",
        "input": "",
        "output": "kubernetes_state_daemonset_updated"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of deployments?",
        "input": "",
        "output": "kubernetes_state_deployment_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of replicas per deployment?",
        "input": "",
        "output": "kubernetes_state_deployment_replicas"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of available replicas per deployment?",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_available"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of unavailable replicas per deployment?",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_unavailable"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of updated replicas per deployment?",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_updated"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of desired replicas per deployment?",
        "input": "",
        "output": "kubernetes_state_deployment_replicas_desired"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of deployments that are paused?",
        "input": "",
        "output": "kubernetes_state_deployment_paused"
    },
    {
        "instruction": "Which Kubernetes metric is used to find the maximum number of unavailable replicas during a rolling update?",
        "input": "",
        "output": "kubernetes_state_deployment_rollingupdate_max_unavailable"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the response size in bytes?",
        "input": "",
        "output": "kubedns_response_size_bytes_sum"
    },
    {
        "instruction": "Which Kubernetes metric is used to count the number of responses evaluated by the kubedns.response_size.bytes.sum metric?",
        "input": "",
        "output": "kubedns_response_size_bytes_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the request duration in seconds?",
        "input": "",
        "output": "kubedns_request_duration_seconds_sum"
    },
    {
        "instruction": "Which Kubernetes metric is used to count the number of requests evaluated by the kubedns.request_duration.seconds.sum metric?",
        "input": "",
        "output": "kubedns_request_duration_seconds_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the total number of DNS requests made?",
        "input": "",
        "output": "kubedns_request_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the instant number of DNS requests made?",
        "input": "",
        "output": "kubedns_request_count_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of DNS requests resulting in an error?",
        "input": "",
        "output": "kubedns_error_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the instant number of DNS requests resulting in an error?",
        "input": "",
        "output": "kubedns_error_count_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of DNS requests resulting in a cache miss?",
        "input": "",
        "output": "kubedns_cachemiss_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the instant number of DNS requests resulting in a cache miss?",
        "input": "",
        "output": "kubedns_cachemiss_count_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of available addresses in an endpoint?",
        "input": "",
        "output": "kubernetes_state_endpoint_address_available"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of addresses not ready in an endpoint?",
        "input": "",
        "output": "kubernetes_state_endpoint_address_not_ready"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the Unix creation timestamp?",
        "input": "",
        "output": "kubernetes_state_endpoint_created"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of jobs?",
        "input": "",
        "output": "kubernetes_state_job_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of failed pods in a job?",
        "input": "",
        "output": "kubernetes_state_job_failed"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of succeeded pods in a job?",
        "input": "",
        "output": "kubernetes_state_job_succeeded"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of namespaces?",
        "input": "",
        "output": "kubernetes_state_namespace_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of nodes?",
        "input": "",
        "output": "kubernetes_state_node_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the total CPU resources of a node?",
        "input": "",
        "output": "kubernetes_state_node_cpu_capacity"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the total memory resources of a node?",
        "input": "",
        "output": "kubernetes_state_node_memory_capacity"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the total pod resources of a node?",
        "input": "",
        "output": "kubernetes_state_node_pods_capacity"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the available GPU resources of a node for scheduling?",
        "input": "",
        "output": "kubernetes_state_node_gpu_cards_allocatable"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the total GPU resources of a node?",
        "input": "",
        "output": "kubernetes_state_node_gpu_cards_capacity"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the available CPU resources of a node for scheduling?",
        "input": "",
        "output": "kubernetes_state_node_cpu_allocatable"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the available memory resources of a node for scheduling",
        "input": "",
        "output": "kubernetes_state_node_memory_allocatable"
    },
    {
        "instruction": "Which Kubernetes metric is used to monitor the available pod resources for scheduling on a node?",
        "input": "",
        "output": "kubernetes_state_node_pods_allocatable"
    },
    {
        "instruction": "Which Kubernetes metric indicates whether a node can schedule new pods?",
        "input": "",
        "output": "kubernetes_state_node_status"
    },
    {
        "instruction": "Which Kubernetes metric, when summed by condition and status, provides the count of nodes in a specific condition?",
        "input": "",
        "output": "kubernetes_state_nodes_by_condition"
    },
    {
        "instruction": "Which Kubernetes metric tracks the container's CPU load average over the past 10 seconds?",
        "input": "",
        "output": "kubernetes_cpu_load_10s_avg"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of cores utilized for system time?",
        "input": "",
        "output": "kubernetes_cpu_system_total"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of cores utilized for user time?",
        "input": "",
        "output": "kubernetes_cpu_user_total"
    },
    {
        "instruction": "Which Kubernetes metric counts the elapsed enforcement period intervals?",
        "input": "",
        "output": "kubernetes_cpu_cfs_periods"
    },
    {
        "instruction": "Which Kubernetes metric counts the throttled period intervals?",
        "input": "",
        "output": "kubernetes_cpu_cfs_throttled_periods"
    },
    {
        "instruction": "Which Kubernetes metric measures the total duration for which the container has been throttled?",
        "input": "",
        "output": "kubernetes_cpu_cfs_throttled_seconds"
    },
    {
        "instruction": "Which Kubernetes metric tracks the number of cores used?",
        "input": "",
        "output": "kubernetes_cpu_usage_total"
    },
    {
        "instruction": "Which Kubernetes metric indicates the limit set for CPU cores?",
        "input": "",
        "output": "kubernetes_cpu_limits"
    },
    {
        "instruction": "Which Kubernetes metric tracks the requested CPU cores?",
        "input": "",
        "output": "kubernetes_cpu_requests"
    },
    {
        "instruction": "Which Kubernetes metric measures the amount of disk storage used?",
        "input": "",
        "output": "kubernetes_filesystem_usage"
    },
    {
        "instruction": "Which Kubernetes metric measures the percentage of disk storage used?",
        "input": "",
        "output": "kubernetes_filesystem_usage_pct"
    },
    {
        "instruction": "Which Kubernetes metric tracks the amount of bytes read from a specific disk?",
        "input": "",
        "output": "kubernetes_io_read_bytes"
    },
    {
        "instruction": "Which Kubernetes metric tracks the amount of bytes written to a specific disk?",
        "input": "",
        "output": "kubernetes_io_write_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the limit set for memory usage?",
        "input": "",
        "output": "kubernetes_memory_limits"
    },
    {
        "instruction": "Which Kubernetes metric indicates the limit set for swap space usage?",
        "input": "",
        "output": "kubernetes_memory_sw_limit"
    },
    {
        "instruction": "Which Kubernetes metric tracks the requested memory by a container?",
        "input": "",
        "output": "kubernetes_memory_requests"
    },
    {
        "instruction": "Which Kubernetes metric is used to monitor the current memory usage in bytes, including all memory regardless of when it was accessed?",
        "input": "",
        "output": "kubernetes_memory_usage"
    },
    {
        "instruction": "Which Kubernetes metric tracks the current working set of memory in bytes, which is observed by the OOM killer?",
        "input": "",
        "output": "kubernetes_memory_working_set"
    },
    {
        "instruction": "Which Kubernetes metric measures the amount of memory used for caching data from disk?",
        "input": "",
        "output": "kubernetes_memory_cache"
    },
    {
        "instruction": "Which Kubernetes metric tracks the size of Resident Set Size (RSS) in bytes?",
        "input": "",
        "output": "kubernetes_memory_rss"
    },
    {
        "instruction": "Which Kubernetes metric measures the amount of swap space currently used by processes in a specific cgroup?",
        "input": "",
        "output": "kubernetes_memory_swap"
    },
    {
        "instruction": "Which Kubernetes metric indicates the percentage of memory used?",
        "input": "",
        "output": "kubernetes_memory_usage_pct"
    },
    {
        "instruction": "Which Kubernetes metric indicates the percentage of swap space used?",
        "input": "",
        "output": "kubernetes_memory_sw_in_use"
    },
    {
        "instruction": "Which Kubernetes metric measures the amount of bytes received per second?",
        "input": "",
        "output": "kubernetes_network_rx_bytes"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of received packets dropped per second?",
        "input": "",
        "output": "kubernetes_network_rx_dropped"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of received errors per second?",
        "input": "",
        "output": "kubernetes_network_rx_errors"
    },
    {
        "instruction": "Which Kubernetes metric measures the amount of bytes transmitted per second?",
        "input": "",
        "output": "kubernetes_network_tx_bytes"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of transmitted packets dropped per second?",
        "input": "",
        "output": "kubernetes_network_tx_dropped"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of transmission errors per second?",
        "input": "",
        "output": "kubernetes_network_tx_errors"
    },
    {
        "instruction": "Which Kubernetes metric tracks the amount of disk space used by a container?",
        "input": "",
        "output": "kubernetes_diskio_io_service_bytes_stats_total"
    },
    {
        "instruction": "Which Kubernetes metric tracks the remaining lifetime of the certificate used to authenticate a request?",
        "input": "",
        "output": "kubernetes_apiserver_certificate_expiration_count"
    },
    {
        "instruction": "Which Kubernetes metric sums the remaining lifetime of certificates used to authenticate requests?",
        "input": "",
        "output": "kubernetes_apiserver_certificate_expiration_sum"
    },
    {
        "instruction": "Which Kubernetes metric tracks the number of HTTP requests?",
        "input": "",
        "output": "kubernetes_rest_client_requests"
    },
    {
        "instruction": "Which Kubernetes metric counts the request latency in seconds, broken down by verb and URL?",
        "input": "",
        "output": "kubernetes_rest_client_latency_count"
    },
    {
        "instruction": "Which Kubernetes metric sums the request latency in seconds, broken down by verb and URL?",
        "input": "",
        "output": "kubernetes_rest_client_latency_sum"
    },
    {
        "instruction": "Which Kubernetes metric tracks the number of runtime operations?",
        "input": "",
        "output": "kubernetes_kubelet_runtime_operations"
    },
    {
        "instruction": "Which Kubernetes metric tracks the number of errors in runtime operations?",
        "input": "",
        "output": "kubernetes_kubelet_runtime_errors"
    },
    {
        "instruction": "Which Kubernetes metric sums the latency in microseconds of network plugin operations?",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_sum"
    },
    {
        "instruction": "Which Kubernetes metric counts the network plugin operations by latency?",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_count"
    },
    {
        "instruction": "Which Kubernetes metric provides the quantiles of network plugin operations by latency?",
        "input": "",
        "output": "kubernetes_kubelet_network_plugin_latency_quantile"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of available bytes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the capacity in bytes of a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of used bytes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the maximum number of inodes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of free inodes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of used inodes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "Which Kubernetes metric tracks the usage of ephemeral storage by a pod?",
        "input": "",
        "output": "kubernetes_ephemeral_storage_usage"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of cores used by the kubelet?",
        "input": "",
        "output": "kubernetes_kubelet_cpu_usage"
    },
    {
        "instruction": "Which Kubernetes metric measures the size of kubelet RSS in bytes?",
        "input": "",
        "output": "kubernetes_kubelet_memory_rss"
    },
    {
        "instruction": "Which Kubernetes metric measures the number of cores used by the runtime?",
        "input": "",
        "output": "kubernetes_runtime_cpu_usage"
    },
    {
        "instruction": "Which Kubernetes metric measures the size of runtime RSS in bytes?",
        "input": "",
        "output": "kubernetes_runtime_memory_rss"
    },
    {
        "instruction": "Which Kubernetes metric tracks the amount of disk space used by a container's logs on the filesystem?",
        "input": "",
        "output": "kubernetes_kubelet_container_log_filesystem_used_bytes"
    },
    {
        "instruction": "Which Kubernetes metric tracks the current phase of a persistent volume claim?",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_status"
    },
    {
        "instruction": "Which Kubernetes metric indicates the storage space requested for a specific persistent volume claim?",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_request_storage"
    },
    {
        "instruction": "Which Kubernetes metric counts the number of persistent volumes, summed by phase and storage class?",
        "input": "",
        "output": "kubernetes_state_persistentvolumes_by_phase"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of available bytes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_available_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the capacity in bytes of a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_capacity_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of used bytes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_used_bytes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the maximum number of inodes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of free inodes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_free"
    },
    {
        "instruction": "Which Kubernetes metric indicates the number of used inodes in a specific volume?",
        "input": "",
        "output": "kubernetes_kubelet_volume_stats_inodes_used"
    },
    {
        "instruction": "Which Kubernetes metric, in association with the condition tag, tracks pods that are ready to serve requests, e.g., condition:true for pods in a ready state.",
        "input": "",
        "output": "kubernetes_state_pod_ready"
    },
    {
        "instruction": "Report the Kubernetes metric used to track the scheduling status of a pod with its tags.",
        "input": "",
        "output": "kubernetes_state_pod_scheduled"
    },
    {
        "instruction": "Which Kubernetes metric is used to report pods that the Kube scheduler cannot schedule on any node?",
        "input": "",
        "output": "kubernetes_state_pod_unschedulable"
    },
    {
        "instruction": "Sum by phase to obtain the count of pods in a given phase, and use namespace to break it down by namespace.",
        "input": "",
        "output": "kubernetes_state_pod_status_phase"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of running pods in a cluster?",
        "input": "",
        "output": "kubernetes_pods_running"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of expired pods in a cluster?",
        "input": "",
        "output": "kubernetes_pods_expired"
    },
    {
        "instruction": "Which Kubernetes metric tracks the current phase of a persistent volume claim?",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_status"
    },
    {
        "instruction": "Which Kubernetes metric indicates the storage space requested for a specific persistent volume claim?",
        "input": "",
        "output": "kubernetes_state_persistentvolumeclaim_request_storage"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of replicasets?",
        "input": "",
        "output": "kubernetes_state_replicaset_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of replicas per ReplicaSet?",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of fully labeled replicas per ReplicaSet?",
        "input": "",
        "output": "kubernetes_state_replicaset_fully_labeled_replicas"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of ready replicas per ReplicaSet?",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas_ready"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of desired pods for a ReplicaSet?",
        "input": "",
        "output": "kubernetes_state_replicaset_replicas_desired"
    },
    {
        "instruction": "Which Kubernetes metric, when summed by namespace and type, provides the count of active services?",
        "input": "",
        "output": "kubernetes_state_service_count"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of replicas per StatefulSet?",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of desired replicas per StatefulSet?",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_desired"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of current replicas per StatefulSet?",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_current"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of ready replicas per StatefulSet?",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_ready"
    },
    {
        "instruction": "Which Kubernetes metric is used to track the number of updated replicas per StatefulSet?",
        "input": "",
        "output": "kubernetes_state_statefulset_replicas_updated"
    },
    {
        "instruction": "kafka topic partition count",
        "input": "",
        "output": "kafka_topic_partition_count"
    },
    {
        "instruction": "kafka topic partition leader count by broker_id by each topic for job='my-job'",
        "input": "",
        "output": "count_values by (topic) ('broker_id',kafka_topic_partition_leader{job='my-job'})"
    },
    {
        "instruction": "counts the occurrences of each unique broker_id across different topics. \nThe metric you are working with is named kafka_topic_partition_leader and it includes a label for the job named 'my-job'.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',kafka_topic_partition_leader{job='my-job'})"
    },
    {
        "instruction": "counts the occurrences of each unique broker_id across different topics. \nThe metric you are working with is named my_very_good_metric and it includes a label for the job named 'my-job'.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',my_very_good_metric{job='my-job'})"
    },
    {
        "instruction": "counts the occurrences of each unique broker_id across different topics. \nThe metric you are working with is named my_very_good_metric and it includes a label for the job named 'my-job'.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',my_very_good_metric{job='my-job'})"
    },
    {
        "instruction": "각 고유 broker_id의 발생 횟수를 토픽별로 계산합니다. 작업하고 있는 메트릭의 이름은 'my_very_good_metric'이며, 'my-job'이라는 job에 한정하여 결과를 도출합니다.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',my_very_good_metric{job='my-job'})"
    },
    {
        "instruction": "각각의 고유 broker_id가 topic별로 몇 번 등장하는지 계산하려고 합니다. 사용 중인 메트릭의 이름은 'my_very_good_metric'이며, 'my-job'이라는 job에 대한 결과만 필요합니다.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',my_very_good_metric{job='my-job'})"
    },
    {
        "instruction": "job='yours' 레이블이 있는 인스턴스에 대해 my_very_good_metric 의 값을 broker_id 로 레이블을 정의하여 값의 발생 횟수를 topic 별로 계산합니다.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',my_very_good_metric{job='yours'})"
    },
    {
        "instruction": "job='yours' 레이블이 있는 인스턴스에 대해 my_very_good_metric 의 값의 레이블을 broker_id 로 정의하여 각 값의 개수를 topic 별로 계산합니다.",
        "input": "",
        "output": "count_values by (topic) ('broker_id',my_very_good_metric{job='yours'})"
    },
    {
        "instruction": "my_very_very_good_metric 의 값의 레이블을 abc 로 정의하여 각 값의 개수를 topic 별로 계산합니다. job='yours' 레이블이 있는 인스턴스에 대해서만 계산합니다.",
        "input": "",
        "output": "count_values by (topic) ('abc',my_very_very_good_metric{job='yours'})"
    },
    {
        "instruction": "kafka_topic_partitions 의 개수를 job='ajob'에 대한 경우에 한정해서 계산합니다.",
        "input": "",
        "output": "kafka_topic_partitions{job='ajob'}"
    },
    {
        "instruction": "kafka_topic_partitions 의 개수를 job='ajob' 레이블이 있는 모든 인스턴스에 대해 계산합니다.",
        "input": "",
        "output": "kafka_topic_partitions{job='ajob'}"
    },
    {
        "instruction": "http_requests_total을 method 로 group by 하여 합산해 보여준다",
        "input": "",
        "output": "sum(http_requests_total) by (method)"
    },
    {
        "instruction": "http_requests_total을 method 로 group by 하여 합산해 보여준다",
        "input": "",
        "output": "sum by (method) (http_requests_total)"
    },
    {
        "instruction": "http_requests_total을 method 별로 합하여 보여준다",
        "input": "",
        "output": "sum by (method) (http_requests_total)"
    },
    {
        "instruction": "host 레이블로 그룹화된 지난 5분 동안 request_count 메트릭의 변경 비율을 구한다.",
        "input": "",
        "output": "rate(request_count[5m]) by (host)"
    },
    {
        "instruction": "host 레이블 단위로 지난 10분간 request_count 메트릭의 변경 비율",
        "input": "",
        "output": "rate(request_count[10m]) by (host)"
    },
    {
        "instruction": "app=api 레이블이 있는 모든 인스턴스에 대해 지난 1시간 동안의 평균 cpu_utilization",
        "input": "",
        "output": "avg(cpu_utilization{app='api'}[1h])"
    },
    {
        "instruction": "app='api' 레이블이 있는 모든 인스턴스에 대해 지난 1시간 동안의 cpu_utilization 값의 평균",
        "input": "",
        "output": "avg(cpu_utilization{app='api'}[1h])"
    },
    {
        "instruction": "app='api' 레이블이 있는 모든 인스턴스에 대해 지난 2시간 동안의 service_metric 값의 평균",
        "input": "",
        "output": "avg(service_metric{app='api'}[2h])"
    },
    {
        "instruction": "app='api' 레이블이 있는 인스턴스에 대해서만 지난 2시간 동안의 service_metric의 평균을 구합니다.",
        "input": "",
        "output": "avg(service_metric{app='api'}[2h])"
    }
]