groups:
  # k8s.pod.* metrics
  - id: metric.k8s.pod.uptime
    type: metric
    metric_name: k8s.pod.uptime
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "The time the Pod has been running"
    entity_associations:
      - k8s.pod
    note: |
      Instrumentations SHOULD use a gauge with type `double` and measure uptime in seconds as a floating point number with the highest precision available.
      The actual accuracy would depend on the instrumentation and operating system.
    instrument: gauge
    unit: "s"
  # k8s.pod.cpu.* metrics
  - id: metric.k8s.pod.cpu.time
    type: metric
    metric_name: k8s.pod.cpu.time
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "Total CPU time consumed"
    entity_associations:
      - k8s.pod
    note: >
      Total CPU time consumed by the specific Pod on all available CPU cores
    instrument: counter
    unit: "s"
  - id: metric.k8s.pod.cpu.usage
    type: metric
    metric_name: k8s.pod.cpu.usage
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "Pod's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs"
    note: >
      CPU usage of the specific Pod on all available CPU cores, averaged over the sample window
    instrument: gauge
    unit: "{cpu}"

  # k8s.pod.memory.* metrics
  - id: metric.k8s.pod.memory.usage
    type: metric
    metric_name: k8s.pod.memory.usage
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Memory usage of the Pod"
    entity_associations:
      - k8s.pod
    note: >
      Total memory usage of the Pod
    instrument: gauge
    unit: "By"

  # k8s.pod.network.* metrics
  - id: metric.k8s.pod.network.io
    type: metric
    metric_name: k8s.pod.network.io
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Network bytes for the Pod"
    instrument: counter
    unit: "By"
    entity_associations:
      - k8s.pod
    attributes:
      - ref: network.interface.name
      - ref: network.io.direction
  - id: metric.k8s.pod.network.errors
    type: metric
    metric_name: k8s.pod.network.errors
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Pod network errors"
    instrument: counter
    entity_associations:
      - k8s.pod
    unit: "{error}"
    attributes:
      - ref: network.interface.name
      - ref: network.io.direction

  # k8s.pod.filesystem.* metrics
  - id: metric.k8s.pod.filesystem.available
    type: metric
    metric_name: k8s.pod.filesystem.available
    stability: development
    brief: "Pod filesystem available bytes"
    instrument: updowncounter
    unit: "By"
    annotations:
      code_generation:
        metric_value_type: int
    entity_associations:
      - k8s.pod
    note: |
      This metric is derived from the
      [FsStats.AvailableBytes](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#FsStats) field
      of the [PodStats.EphemeralStorage](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#PodStats)
      of the Kubelet's stats API.
  - id: metric.k8s.pod.filesystem.capacity
    type: metric
    metric_name: k8s.pod.filesystem.capacity
    stability: development
    brief: "Pod filesystem capacity"
    instrument: updowncounter
    unit: "By"
    annotations:
      code_generation:
        metric_value_type: int
    entity_associations:
      - k8s.pod
    note: |
      This metric is derived from the
      [FsStats.CapacityBytes](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#FsStats) field
      of the [PodStats.EphemeralStorage](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#PodStats)
      of the Kubelet's stats API.
  - id: metric.k8s.pod.filesystem.usage
    type: metric
    metric_name: k8s.pod.filesystem.usage
    stability: development
    brief: "Pod filesystem usage"
    instrument: updowncounter
    unit: "By"
    annotations:
      code_generation:
        metric_value_type: int
    entity_associations:
      - k8s.pod
    note: |
      This may not equal capacity - available.

      This metric is derived from the
      [FsStats.UsedBytes](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#FsStats) field
      of the [PodStats.EphemeralStorage](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#PodStats)
      of the Kubelet's stats API.

  # k8s.container.* metrics
  - id: metric.k8s.container.status.state
    type: metric
    metric_name: k8s.container.status.state
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Describes the number of K8s containers that are currently in a given state"
    note: |
      All possible container states will be reported at each time interval to avoid missing metrics.
      Only the value corresponding to the current state will be non-zero.
    instrument: updowncounter
    unit: "{container}"
    entity_associations:
      - k8s.container
    attributes:
      - ref: k8s.container.status.state
        requirement_level: required
  - id: metric.k8s.container.status.reason
    type: metric
    metric_name: k8s.container.status.reason
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Describes the number of K8s containers that are currently in a state for a given reason"
    instrument: updowncounter
    unit: "{container}"
    entity_associations:
      - k8s.container
    note: |
      All possible container state reasons will be reported at each time interval to avoid missing metrics.
      Only the value corresponding to the current state reason will be non-zero.
    attributes:
      - ref: k8s.container.status.reason
        requirement_level: required

  # k8s.node.* metrics
  - id: metric.k8s.node.uptime
    type: metric
    metric_name: k8s.node.uptime
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "The time the Node has been running"
    note: |
      Instrumentations SHOULD use a gauge with type `double` and measure uptime in seconds as a floating point number with the highest precision available.
      The actual accuracy would depend on the instrumentation and operating system.
    instrument: gauge
    unit: "s"
    entity_associations:
      - k8s.node
  # k8s.node.allocatable.* metrics
  - id: metric.k8s.node.allocatable.cpu
    type: metric
    metric_name: k8s.node.allocatable.cpu
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "Amount of cpu allocatable on the node"
    entity_associations:
      - k8s.node
    instrument: updowncounter
    unit: "{cpu}"
  - id: metric.k8s.node.allocatable.ephemeral_storage
    type: metric
    metric_name: k8s.node.allocatable.ephemeral_storage
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Amount of ephemeral-storage allocatable on the node"
    entity_associations:
      - k8s.node
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.node.allocatable.memory
    type: metric
    metric_name: k8s.node.allocatable.memory
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Amount of memory allocatable on the node"
    entity_associations:
      - k8s.node
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.node.allocatable.pods
    type: metric
    metric_name: k8s.node.allocatable.pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Amount of pods allocatable on the node"
    entity_associations:
      - k8s.node
    instrument: updowncounter
    unit: "{pod}"
  # k8s.node.condition.* metrics
  - id: metric.k8s.node.condition.status
    type: metric
    metric_name: k8s.node.condition.status
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Describes the condition of a particular Node."
    note: >
      All possible node condition pairs (type and status) will be reported at each time interval to avoid missing metrics.
      Condition pairs corresponding to the current conditions' statuses will be non-zero.
    instrument: updowncounter
    unit: "{node}"
    entity_associations:
      - k8s.node
    attributes:
      - ref: k8s.node.condition.type
        requirement_level: required
      - ref: k8s.node.condition.status
        requirement_level: required
  # k8s.node.cpu.* metrics
  - id: metric.k8s.node.cpu.time
    type: metric
    metric_name: k8s.node.cpu.time
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "Total CPU time consumed"
    note: >
      Total CPU time consumed by the specific Node on all available CPU cores
    instrument: counter
    entity_associations:
      - k8s.node
    unit: "s"
  - id: metric.k8s.node.cpu.usage
    type: metric
    metric_name: k8s.node.cpu.usage
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "Node's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs"
    note: >
      CPU usage of the specific Node on all available CPU cores, averaged over the sample window
    instrument: gauge
    entity_associations:
      - k8s.node
    unit: "{cpu}"

  # k8s.node.filesystem.* metrics
  - id: metric.k8s.node.filesystem.available
    type: metric
    metric_name: k8s.node.filesystem.available
    stability: development
    brief: "Node filesystem available bytes"
    instrument: updowncounter
    unit: "By"
    annotations:
      code_generation:
        metric_value_type: int
    entity_associations:
      - k8s.node
    note: |
      This metric is derived from the
      [FsStats.AvailableBytes](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#FsStats) field
      of the [NodeStats.Fs](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#NodeStats)
      of the Kubelet's stats API.
  - id: metric.k8s.node.filesystem.capacity
    type: metric
    metric_name: k8s.node.filesystem.capacity
    stability: development
    brief: "Node filesystem capacity"
    instrument: updowncounter
    unit: "By"
    annotations:
      code_generation:
        metric_value_type: int
    entity_associations:
      - k8s.node
    note: |
      This metric is derived from the
      [FsStats.CapacityBytes](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#FsStats) field
      of the [NodeStats.Fs](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#NodeStats)
      of the Kubelet's stats API.
  - id: metric.k8s.node.filesystem.usage
    type: metric
    metric_name: k8s.node.filesystem.usage
    stability: development
    brief: "Node filesystem usage"
    instrument: updowncounter
    unit: "By"
    annotations:
      code_generation:
        metric_value_type: int
    entity_associations:
      - k8s.node
    note: |
      This may not equal capacity - available.

      This metric is derived from the
      [FsStats.UsedBytes](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#FsStats) field
      of the [NodeStats.Fs](https://pkg.go.dev/k8s.io/kubelet@v0.33.0/pkg/apis/stats/v1alpha1#NodeStats)
      of the Kubelet's stats API.

  # k8s.node.memory.* metrics
  - id: metric.k8s.node.memory.usage
    type: metric
    metric_name: k8s.node.memory.usage
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Memory usage of the Node"
    note: >
      Total memory usage of the Node
    instrument: gauge
    entity_associations:
      - k8s.node
    unit: "By"

  # k8s.node.network.* metrics
  - id: metric.k8s.node.network.io
    type: metric
    metric_name: k8s.node.network.io
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Network bytes for the Node"
    instrument: counter
    unit: "By"
    entity_associations:
      - k8s.node
    attributes:
      - ref: network.interface.name
      - ref: network.io.direction
  - id: metric.k8s.node.network.errors
    type: metric
    metric_name: k8s.node.network.errors
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Node network errors"
    instrument: counter
    unit: "{error}"
    entity_associations:
      - k8s.node
    attributes:
      - ref: network.interface.name
      - ref: network.io.direction

  # k8s.deployment.* metrics
  - id: metric.k8s.deployment.desired_pods
    type: metric
    metric_name: k8s.deployment.desired_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of desired replica pods in this deployment"
    entity_associations:
      - k8s.deployment
    note: |
      This metric aligns with the `replicas` field of the
      [K8s DeploymentSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentspec-v1-apps).
    instrument: updowncounter
    unit: "{pod}"
  - id: metric.k8s.deployment.available_pods
    type: metric
    metric_name: k8s.deployment.available_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    entity_associations:
      - k8s.deployment
    brief: "Total number of available replica pods (ready for at least minReadySeconds) targeted by this deployment"
    note: |
      This metric aligns with the `availableReplicas` field of the
      [K8s DeploymentStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentstatus-v1-apps).
    instrument: updowncounter
    unit: "{pod}"

  # k8s.replicaset.* metrics
  - id: metric.k8s.replicaset.desired_pods
    type: metric
    metric_name: k8s.replicaset.desired_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of desired replica pods in this replicaset"
    entity_associations:
      - k8s.replicaset
    note: |
      This metric aligns with the `replicas` field of the
      [K8s ReplicaSetSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetspec-v1-apps).
    instrument: updowncounter
    unit: "{pod}"
  - id: metric.k8s.replicaset.available_pods
    type: metric
    metric_name: k8s.replicaset.available_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    entity_associations:
      - k8s.replicaset
    brief: "Total number of available replica pods (ready for at least minReadySeconds) targeted by this replicaset"
    note: |
      This metric aligns with the `availableReplicas` field of the
      [K8s ReplicaSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetstatus-v1-apps).
    instrument: updowncounter
    unit: "{pod}"

  # k8s.replicationcontroller.* metrics
  - id: metric.k8s.replicationcontroller.desired_pods
    type: metric
    metric_name: k8s.replicationcontroller.desired_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of desired replica pods in this replication controller"
    entity_associations:
      - k8s.replicationcontroller
    note: |
      This metric aligns with the `replicas` field of the
      [K8s ReplicationControllerSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core)
    instrument: updowncounter
    unit: "{pod}"
  - id: metric.k8s.replicationcontroller.available_pods
    type: metric
    metric_name: k8s.replicationcontroller.available_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    entity_associations:
      - k8s.replicationcontroller
    brief: "Total number of available replica pods (ready for at least minReadySeconds) targeted by this replication controller"
    note: |
      This metric aligns with the `availableReplicas` field of the
      [K8s ReplicationControllerStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core)
    instrument: updowncounter
    unit: "{pod}"

  # k8s.statefulset.* metrics
  - id: metric.k8s.statefulset.desired_pods
    type: metric
    metric_name: k8s.statefulset.desired_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of desired replica pods in this statefulset"
    entity_associations:
      - k8s.statefulset
    note: |
      This metric aligns with the `replicas` field of the
      [K8s StatefulSetSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetspec-v1-apps).
    instrument: updowncounter
    unit: "{pod}"
  - id: metric.k8s.statefulset.ready_pods
    type: metric
    metric_name: k8s.statefulset.ready_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    entity_associations:
      - k8s.statefulset
    brief: "The number of replica pods created for this statefulset with a Ready Condition"
    note: |
      This metric aligns with the `readyReplicas` field of the
      [K8s StatefulSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps).
    instrument: updowncounter
    unit: "{pod}"
  - id: metric.k8s.statefulset.current_pods
    type: metric
    metric_name: k8s.statefulset.current_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    entity_associations:
      - k8s.statefulset
    brief: "The number of replica pods created by the statefulset controller from the statefulset version indicated by currentRevision"
    note: |
      This metric aligns with the `currentReplicas` field of the
      [K8s StatefulSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps).
    instrument: updowncounter
    unit: "{pod}"
  - id: metric.k8s.statefulset.updated_pods
    type: metric
    metric_name: k8s.statefulset.updated_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    entity_associations:
      - k8s.statefulset
    brief: "Number of replica pods created by the statefulset controller from the statefulset version indicated by updateRevision"
    note: |
      This metric aligns with the `updatedReplicas` field of the
      [K8s StatefulSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps).
    instrument: updowncounter
    unit: "{pod}"

  # k8s.hpa.* metrics
  - id: metric.k8s.hpa.desired_pods
    type: metric
    metric_name: k8s.hpa.desired_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by the autoscaler"
    note: |
      This metric aligns with the `desiredReplicas` field of the
      [K8s HorizontalPodAutoscalerStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling)
    instrument: updowncounter
    entity_associations:
      - k8s.hpa
    unit: "{pod}"
  - id: metric.k8s.hpa.current_pods
    type: metric
    metric_name: k8s.hpa.current_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the autoscaler"
    note: |
      This metric aligns with the `currentReplicas` field of the
      [K8s HorizontalPodAutoscalerStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling)
    instrument: updowncounter
    entity_associations:
      - k8s.hpa
    unit: "{pod}"
  - id: metric.k8s.hpa.max_pods
    type: metric
    metric_name: k8s.hpa.max_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The upper limit for the number of replica pods to which the autoscaler can scale up"
    note: |
      This metric aligns with the `maxReplicas` field of the
      [K8s HorizontalPodAutoscalerSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling)
    instrument: updowncounter
    entity_associations:
      - k8s.hpa
    unit: "{pod}"
  - id: metric.k8s.hpa.min_pods
    type: metric
    metric_name: k8s.hpa.min_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The lower limit for the number of replica pods to which the autoscaler can scale down"
    note: |
      This metric aligns with the `minReplicas` field of the
      [K8s HorizontalPodAutoscalerSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling)
    instrument: updowncounter
    entity_associations:
      - k8s.hpa
    unit: "{pod}"
  - id: metric.k8s.hpa.metric.target.cpu.value
    type: metric
    metric_name: k8s.hpa.metric.target.cpu.value
    stability: development
    brief: "Target value for CPU resource in HPA config."
    note: |
      This metric aligns with the `value` field of the
      [K8s HPA MetricTarget](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#metrictarget-v2-autoscaling).
      If the type of the metric is [`ContainerResource`](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#support-for-metrics-apis),
      the `k8s.container.name` attribute MUST be set to identify the specific container within the pod to which the metric applies.
    instrument: gauge
    unit: "{cpu}"
    attributes:
      - ref: k8s.hpa.metric.type
      - ref: k8s.container.name
        requirement_level:
          conditionally_required: if and only if k8s.hpa.metric.type is ContainerResource
    entity_associations:
      - k8s.hpa
      - k8s.namespace
  - id: metric.k8s.hpa.metric.target.cpu.average_value
    type: metric
    metric_name: k8s.hpa.metric.target.cpu.average_value
    stability: development
    brief: "Target average value for CPU resource in HPA config."
    note: |
      This metric aligns with the `averageValue` field of the
      [K8s HPA MetricTarget](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#metrictarget-v2-autoscaling).
      If the type of the metric is [`ContainerResource`](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#support-for-metrics-apis),
      the `k8s.container.name` attribute MUST be set to identify the specific container within the pod to which the metric applies.
    instrument: gauge
    unit: "{cpu}"
    attributes:
      - ref: k8s.hpa.metric.type
      - ref: k8s.container.name
        requirement_level:
          conditionally_required: if and only if k8s.hpa.metric.type is ContainerResource
    entity_associations:
      - k8s.hpa
      - k8s.namespace
  - id: metric.k8s.hpa.metric.target.cpu.average_utilization
    type: metric
    metric_name: k8s.hpa.metric.target.cpu.average_utilization
    stability: development
    brief: "Target average utilization, in percentage, for CPU resource in HPA config."
    note: |
      This metric aligns with the `averageUtilization` field of the
      [K8s HPA MetricTarget](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#metrictarget-v2-autoscaling).
      If the type of the metric is [`ContainerResource`](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#support-for-metrics-apis),
      the `k8s.container.name` attribute MUST be set to identify the specific container within the pod to which the metric applies.
    instrument: gauge
    unit: "1"
    attributes:
      - ref: k8s.hpa.metric.type
      - ref: k8s.container.name
        requirement_level:
          conditionally_required: if and only if k8s.hpa.metric.type is ContainerResource.
    entity_associations:
      - k8s.hpa
      - k8s.namespace

  # k8s.daemonset.* metrics
  - id: metric.k8s.daemonset.current_scheduled_nodes
    type: metric
    metric_name: k8s.daemonset.current_scheduled_nodes
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod"
    note: |
      This metric aligns with the `currentNumberScheduled` field of the
      [K8s DaemonSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps).
    instrument: updowncounter
    entity_associations:
      - k8s.daemonset
    unit: "{node}"
  - id: metric.k8s.daemonset.desired_scheduled_nodes
    type: metric
    metric_name: k8s.daemonset.desired_scheduled_nodes
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of nodes that should be running the daemon pod (including nodes currently running the daemon pod)"
    note: |
      This metric aligns with the `desiredNumberScheduled` field of the
      [K8s DaemonSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps).
    instrument: updowncounter
    entity_associations:
      - k8s.daemonset
    unit: "{node}"
  - id: metric.k8s.daemonset.misscheduled_nodes
    type: metric
    metric_name: k8s.daemonset.misscheduled_nodes
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod"
    note: |
      This metric aligns with the `numberMisscheduled` field of the
      [K8s DaemonSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps).
    instrument: updowncounter
    entity_associations:
      - k8s.daemonset
    unit: "{node}"
  - id: metric.k8s.daemonset.ready_nodes
    type: metric
    metric_name: k8s.daemonset.ready_nodes
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready"
    note: |
      This metric aligns with the `numberReady` field of the
      [K8s DaemonSetStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps).
    instrument: updowncounter
    entity_associations:
      - k8s.daemonset
    unit: "{node}"

  # k8s.job.* metrics
  - id: metric.k8s.job.active_pods
    type: metric
    metric_name: k8s.job.active_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The number of pending and actively running pods for a job"
    instrument: updowncounter
    unit: "{pod}"
    entity_associations:
      - k8s.job
    note: |
      This metric aligns with the `active` field of the
      [K8s JobStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch).
  - id: metric.k8s.job.failed_pods
    type: metric
    metric_name: k8s.job.failed_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The number of pods which reached phase Failed for a job"
    instrument: updowncounter
    unit: "{pod}"
    entity_associations:
      - k8s.job
    note: |
      This metric aligns with the `failed` field of the
      [K8s JobStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch).
  - id: metric.k8s.job.successful_pods
    type: metric
    metric_name: k8s.job.successful_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The number of pods which reached phase Succeeded for a job"
    instrument: updowncounter
    unit: "{pod}"
    entity_associations:
      - k8s.job
    note: |
      This metric aligns with the `succeeded` field of the
      [K8s JobStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch).
  - id: metric.k8s.job.desired_successful_pods
    type: metric
    metric_name: k8s.job.desired_successful_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The desired number of successfully finished pods the job should be run with"
    instrument: updowncounter
    unit: "{pod}"
    entity_associations:
      - k8s.job
    note: |
      This metric aligns with the `completions` field of the
      [K8s JobSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch)..
  - id: metric.k8s.job.max_parallel_pods
    type: metric
    metric_name: k8s.job.max_parallel_pods
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The max desired number of pods the job should run at any given time"
    instrument: updowncounter
    unit: "{pod}"
    entity_associations:
      - k8s.job
    note: |
      This metric aligns with the `parallelism` field of the
      [K8s JobSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch).

  # k8s.cronjob.* metrics
  - id: metric.k8s.cronjob.active_jobs
    type: metric
    metric_name: k8s.cronjob.active_jobs
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "The number of actively running jobs for a cronjob"
    instrument: updowncounter
    unit: "{job}"
    entity_associations:
      - k8s.cronjob
    note: |
      This metric aligns with the `active` field of the
      [K8s CronJobStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#cronjobstatus-v1-batch).

  # k8s.namespace.* metrics
  - id: metric.k8s.namespace.phase
    type: metric
    metric_name: k8s.namespace.phase
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Describes number of K8s namespaces that are currently in a given phase."
    instrument: updowncounter
    unit: "{namespace}"
    entity_associations:
      - k8s.namespace
    attributes:
      - ref: k8s.namespace.phase
        requirement_level: required

  # k8s.container.* metrics
  - id: metric.k8s.container.cpu.limit
    type: metric
    metric_name: k8s.container.cpu.limit
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "Maximum CPU resource limit set for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "{cpu}"
  - id: metric.k8s.container.cpu.request
    type: metric
    metric_name: k8s.container.cpu.request
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: "CPU resource requested for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "{cpu}"
  - id: metric.k8s.container.memory.limit
    type: metric
    metric_name: k8s.container.memory.limit
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Maximum memory resource limit set for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.container.memory.request
    type: metric
    metric_name: k8s.container.memory.request
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Memory resource requested for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.container.storage.limit
    type: metric
    metric_name: k8s.container.storage.limit
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Maximum storage resource limit set for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.container.storage.request
    type: metric
    metric_name: k8s.container.storage.request
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Storage resource requested for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.container.ephemeral_storage.limit
    type: metric
    metric_name: k8s.container.ephemeral_storage.limit
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Maximum ephemeral storage resource limit set for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.container.ephemeral_storage.request
    type: metric
    metric_name: k8s.container.ephemeral_storage.request
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Ephemeral storage resource requested for the container"
    entity_associations:
      - k8s.container
    note: |
      See https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#resourcerequirements-v1-core for details.
    instrument: updowncounter
    unit: "By"
  - id: metric.k8s.container.restart.count
    type: metric
    metric_name: k8s.container.restart.count
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: "Describes how many times the container has restarted (since the last counter reset)"
    instrument: updowncounter
    unit: "{restart}"
    entity_associations:
      - k8s.container
    note: |
      This value is pulled directly from the K8s API and the value can go indefinitely high and be reset to 0
      at any time depending on how your kubelet is configured to prune dead containers.
      It is best to not depend too much on the exact value but rather look at it as
      either == 0, in which case you can conclude there were no restarts in the recent past, or > 0, in which case
      you can conclude there were restarts in the recent past, and not try and analyze the value beyond that.
  - id: metric.k8s.container.ready
    type: metric
    metric_name: k8s.container.ready
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: >
      Indicates whether the container is currently marked as ready to accept traffic,
      based on its readiness probe (1 = ready, 0 = not ready)
    instrument: updowncounter
    unit: "{container}"
    entity_associations:
      - k8s.container
    note: |
      This metric SHOULD reflect the value of the `ready` field in the
      [K8s ContainerStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#containerstatus-v1-core).

  # k8s.resourcequota.cpu.* metrics
  - id: metric.k8s.resourcequota.cpu.limit.hard
    type: metric
    metric_name: k8s.resourcequota.cpu.limit.hard
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: |
      The CPU limits in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "{cpu}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.cpu.limit.used
    type: metric
    metric_name: k8s.resourcequota.cpu.limit.used
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: |
      The CPU limits in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "{cpu}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.cpu.request.hard
    type: metric
    metric_name: k8s.resourcequota.cpu.request.hard
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: |
      The CPU requests in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "{cpu}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.cpu.request.used
    type: metric
    metric_name: k8s.resourcequota.cpu.request.used
    annotations:
      code_generation:
        metric_value_type: double
    stability: development
    brief: |
      The CPU requests in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "{cpu}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

  # k8s.resourcequota.memory.* metrics
  - id: metric.k8s.resourcequota.memory.limit.hard
    type: metric
    metric_name: k8s.resourcequota.memory.limit.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The memory limits in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.memory.limit.used
    type: metric
    metric_name: k8s.resourcequota.memory.limit.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The memory limits in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.memory.request.hard
    type: metric
    metric_name: k8s.resourcequota.memory.request.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The memory requests in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.memory.request.used
    type: metric
    metric_name: k8s.resourcequota.memory.request.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The memory requests in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

  # k8s.resourcequota.hugepage_count.* metrics
  - id: metric.k8s.resourcequota.hugepage_count.request.hard
    type: metric
    metric_name: k8s.resourcequota.hugepage_count.request.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The huge page requests in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "{hugepage}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
    attributes:
      - ref: k8s.hugepage.size
        requirement_level: required
  - id: metric.k8s.resourcequota.hugepage_count.request.used
    type: metric
    metric_name: k8s.resourcequota.hugepage_count.request.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The huge page requests in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "{hugepage}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
    attributes:
      - ref: k8s.hugepage.size
        requirement_level: required

  # k8s.resourcequota.storage.* metrics
  - id: metric.k8s.resourcequota.storage.request.hard
    type: metric
    metric_name: k8s.resourcequota.storage.request.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The storage requests in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

      The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
      storage class.
    attributes:
      - ref: k8s.storageclass.name
        requirement_level:
          conditionally_required: |
            The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
            storage class.
  - id: metric.k8s.resourcequota.storage.request.used
    type: metric
    metric_name: k8s.resourcequota.storage.request.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The storage requests in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

      The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
      storage class.
    attributes:
      - ref: k8s.storageclass.name
        requirement_level:
          conditionally_required: |
            The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
            storage class.

  # k8s.resourcequota.persistentvolumeclaim_count.* metrics
  - id: metric.k8s.resourcequota.persistentvolumeclaim_count.hard
    type: metric
    metric_name: k8s.resourcequota.persistentvolumeclaim_count.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The total number of PersistentVolumeClaims that can exist in the namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "{persistentvolumeclaim}"
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

      The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
      storage class.
    attributes:
      - ref: k8s.storageclass.name
        requirement_level:
          conditionally_required: |
            The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
            storage class.
  - id: metric.k8s.resourcequota.persistentvolumeclaim_count.used
    type: metric
    metric_name: k8s.resourcequota.persistentvolumeclaim_count.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The total number of PersistentVolumeClaims that can exist in the namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "{persistentvolumeclaim}"
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

      The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
      storage class.
    attributes:
      - ref: k8s.storageclass.name
        requirement_level:
          conditionally_required: |
            The `k8s.storageclass.name` should be required when a resource quota is defined for a specific
            storage class.

  # k8s.resourcequota.ephemeral_storage.* metrics
  - id: metric.k8s.resourcequota.ephemeral_storage.request.hard
    type: metric
    metric_name: k8s.resourcequota.ephemeral_storage.request.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The sum of local ephemeral storage requests in the namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.ephemeral_storage.request.used
    type: metric
    metric_name: k8s.resourcequota.ephemeral_storage.request.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The sum of local ephemeral storage requests in the namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.ephemeral_storage.limit.hard
    type: metric
    metric_name: k8s.resourcequota.ephemeral_storage.limit.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The sum of local ephemeral storage limits in the namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
  - id: metric.k8s.resourcequota.ephemeral_storage.limit.used
    type: metric
    metric_name: k8s.resourcequota.ephemeral_storage.limit.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The sum of local ephemeral storage limits in the namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "By"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).

  # k8s.resourcequota.object_count metric
  - id: metric.k8s.resourcequota.object_count.hard
    type: metric
    metric_name: k8s.resourcequota.object_count.hard
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The object count limits in a specific namespace.
      The value represents the configured quota limit of the resource in the namespace.
    instrument: updowncounter
    unit: "{object}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `hard` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
    attributes:
      - ref: k8s.resourcequota.resource_name
        requirement_level: required
  - id: metric.k8s.resourcequota.object_count.used
    type: metric
    metric_name: k8s.resourcequota.object_count.used
    annotations:
      code_generation:
        metric_value_type: int
    stability: development
    brief: |
      The object count limits in a specific namespace.
      The value represents the current observed total usage of the resource in the namespace.
    instrument: updowncounter
    unit: "{object}"
    entity_associations:
      - k8s.resourcequota
    note: |
      This metric is retrieved from the `used` field of the
      [K8s ResourceQuotaStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcequotastatus-v1-core).
    attributes:
      - ref: k8s.resourcequota.resource_name
        requirement_level: required