Edge Delta Metrics List

Metrics handled by Edge Delta.

  16 minute read  

This page lists metrics in Edge Delta. For accurate interpretation and pipeline design you should examine your actual data using the metrics inventory, node tests, and the debug node.

General Metrics

Metric Definition
ed.agent.cpu.milicores The metric ed.agent.cpu.milicores (formerly known as agent_cpu_millicores.value) in Edge Delta measures the CPU usage of the Edge Delta agent in millicores. This metric is useful for understanding how much CPU is being consumed by the agent, which can help identify performance bottlenecks or inefficiencies.
ed.agent.gc.count The metric ed.agent.gc.count (formerly known as agent_gc_count.value) in Edge Delta represents the total number of garbage collection operations carried out by the Edge Delta agent. This metric helps in understanding the frequency of garbage collection processes, which can indicate how efficiently the agent is managing memory.
ed.agent.gc.forced_count The metric ed.agent.gc.forced_count (formerly known as agent_gc_forced_count.value) in Edge Delta indicates the number of times garbage collection was manually triggered within the Edge Delta agent. This metric is useful for tracking how often forced garbage collection occurs, which can be indicative of memory management strategies or issues.
ed.agent.gc.pause_time The metric ed.agent.gc.pause_time (formerly known as agent_gc_pause_ms.value) in Edge Delta refers to the duration of garbage collection pauses in milliseconds. This metric is useful for diagnosing performance issues related to the time it takes the garbage collector to complete its cycle within the Edge Delta agent.
ed.agent.gc.target The metric ed.agent.gc.target (formerly known as agent_gc_target.value) in Edge Delta is related to the garbage collection target of the Edge Delta agent. This metric helps in monitoring and managing the garbage collection process within the agent.
ed.agent.go.routine.value The metric ed.agent.go.routine.value (formerly agent_num_goroutine.value) in Edge Delta tracks the number of goroutines in use by the Edge Delta agent. This metric is useful for understanding how many concurrent operations or threads the agent is handling.
ed.agent.memory.allocation The metric ed.agent.memory.allocation (formerly agent_mem_alloc.value) in Edge Delta refers to the memory allocation of the Edge Delta agent. This metric is used to monitor the amount of memory that the agent is currently using.
ed.agent.memory.to_be_freed The metric ed.agent.memory.to_be_freed (formerly agent_mem_to_be_freed.value) in Edge Delta refers to the memory that is marked to be freed by the Edge Delta agent. This metric helps in understanding how much memory is expected to be released soon by the agent.
ed.agent.memory.virtual The metric ed.agent.memory.virtual (formerly agent_mem_virtual.value) in Edge Delta refers to the memory that is reserved for the Edge Delta agent, including both the physical and swap memory that has been allocated. It provides insights into the total address space reserved by the agent.
ed.host.cpu.process_count The metric ed.host.cpu.process_count (formerly known as process_count.value) tracks the number of processes currently running on the host. This provides insights into the system’s load and can indicate resource usage trends.
ed.host.cpu.system.average The metric ed.host.cpu.system.average (formerly known as cpu_system_avg.value) tracks the average percentage of CPU time consumed by system processes across all CPUs on a host. This offers an overview of the CPU resources used for system-level tasks over time.
ed.host.cpu.user.average The metric ed.host.cpu.user.average (formerly known as cpu_user_avg.value) measures the average percentage of CPU time used by user-level processes across all CPUs on a host. This metric provides insights into overall CPU usage by applications running in user mode.
ed.host.cpu#.system.average The metric ed.host.cpu#.system.average (formerly known as cpu#_system_avg.value) represents the average percentage of CPU time spent on system processes on a specific host. This metric provides insights into how much CPU resources are allocated for operating system tasks over a period of time.
ed.host.cpu#.system.percent The metric ed.host.cpu#.system.percent (formerly known as cpu#_system_perc.value) measures the percentage of CPU time spent on system processes on a specific host. This metric helps in understanding the proportion of CPU resources used by the operating system for various internal tasks.
ed.host.cpu#.user.average The metric ed.host.cpu#.user.average (formerly known as cpu#_user_avg.value) represents the average percentage of CPU time used by user processes on a particular host. This metric provides insights into how much CPU resources are being utilized by applications and services running in user mode.
ed.host.cpu#.user.percent The metric ed.host.cpu#.user.percent (formerly known as cpu#_user_perc.value) measures the percentage of CPU spent on user processes on a specific host. This metric is valuable for monitoring how much CPU time is being consumed by user-level applications.
ed.host.disk.read_bytes The metric ed.host.disk.read_bytes (formerly known as disk_read_bytes.value) measures the total number of bytes read from disk by the host. This metric provides insight into disk I/O activity, specifically focusing on data read operations.
ed.host.disk.write_bytes The metric ed.host.disk.write_bytes (formerly known as disk_write_bytes.value) captures the total number of bytes written to disk on the host. This metric provides insights into disk write activities, highlighting data throughput and potential I/O bottlenecks during write operations.
ed.host.memory.total The metric ed.host.memory.total (formerly known as memory_total.value) represents the total amount of memory available on a host. This metric includes both physical and virtual memory, providing an overall view of the memory resources available for the system.
ed.host.memory.used.percentage The metric ed.host.memory.used.percentage (formerly known as memory_used_perc.value) indicates the percentage of total memory currently in use on a host. This metric helps in assessing memory utilization and identifying potential memory resource constraints.
ed.host.memory.used.value The metric ed.host.memory.used.value (formerly known as memory_used.value) tracks the amount of memory currently used on a host. This includes memory used by all processes and the operating system, providing insights into the total memory consumption.
ed.host.net.read_bytes The metric ed.host.net.read_bytes (formerly known as net_received_bytes.value) refers to the total number of bytes received over the network by the host. This provides insights into network activity concerning incoming data traffic.
ed.host.net.write_bytes The metric ed.host.net.write_bytes (formerly known as net_sent_bytes.value) represents the total number of bytes sent over the network by the host. This metric provides insights into network activity concerning outgoing data traffic.
ed.pipeline.l2m.log_threshold The metric ed.pipeline.l2m.log_threshold (formerly known as log_threshold_monitor_metric) is related to monitoring log thresholds in a pipeline setting. This metric helps evaluate log counts across all agents, assisting in the detection of log anomalies or patterns exceeding predefined thresholds.
ed.pipeline.node.read_bytes The metric ed.pipeline.node.read_bytes (formerly known as in_bytes) measures the total bytes read by a particular node in the pipeline. This provides insights into the data ingestion volume handled by that node.
ed.pipeline.node.read_items The metric ed.pipeline.node.read_items (formerly known as in_items) tracks the number of items or records read by a specific node within the pipeline. This provides insights into the volume of data processed by the node in terms of item count.
ed.pipeline.node.write_bytes The metric ed.pipeline.node.write_bytes (formerly known as out_bytes) records the total number of bytes written by a specific node in the pipeline. This metric helps track data egress handled by that node in terms of bytes outputted.
ed.pipeline.node.write_items The metric ed.pipeline.node.write_items (formerly known as out_items) tracks the number of items or records written by a specific node in the pipeline. This metric provides insight into the volume of data outputted by the node in terms of item count.
ed.pipeline.raw_write_bytes The metric ed.pipeline.raw_write_bytes (formerly known as outgoing_raw_bytes.sum) captures the total amount of raw byte data outputted by the pipeline. This metric provides insight into the volume of raw data transmitted.
ed.pipeline.read_bytes The metric ed.pipeline.read_bytes (formerly known as incoming_bytes.sum) measures the total amount of incoming bytes processed by the pipeline. This provides an overview of the data ingress in terms of byte volume.
ed.pipeline.read_items The metric ed.pipeline.read_items (formerly known as incoming_lines.count) indicates the number of lines processed by the pipeline. This metric helps in measuring data ingress in terms of line count.
ed.pipeline.uncompressed_write_bytes The metric ed.pipeline.uncompressed_write_bytes (formerly known as outgoing_uncompressed_bytes.sum) measures the total number of uncompressed bytes outputted by the pipeline. This metric is used to assess the volume of data transmitted without any compression applied.
ed.pipeline.write_bytes The metric ed.pipeline.write_bytes (formerly known as outgoing_bytes.sum) tracks the total number of bytes written or outputted by the pipeline. This metric helps in understanding the total data egress in terms of byte volume.
ed.pipeline.write_items The metric ed.pipeline.write_items (formerly known as outgoing_lines.count) represents the count of lines or items that have been outputted by the pipeline. This metric is useful for understanding the data egress in terms of item count.

K8s Metrics

By default, the Metrics Source node scrapes kube_state_metrics. As of v1.27.0 kubelet, cadvisor, and node_exporter metrics are excluded by default. You can remove them from the exclude list if you want to include them.

Kubelet Metrics

Metric Definition
k8s.kubelet.process.cpu_seconds.rate The metric k8s.kubelet.process.cpu_seconds.rate (formerly known as ed_k8s_metric_process_cpu_seconds.rate) measures the rate of CPU time consumed by the Kubelet process. This metric is essential for monitoring the CPU utilization of the Kubelet service.
k8s.kubelet.process.cpu_seconds.value The metric k8s.kubelet.process.cpu_seconds.value (formerly known as ed_k8s_metric_process_cpu_seconds.value) measures the total CPU seconds consumed by the Kubelet process. This metric provides insight into the overall CPU time that the Kubelet service has utilized.
k8s.kubelet.process.resident_memory_bytes.value The metric k8s.kubelet.process.resident_memory_bytes.value (formerly known as ed_k8s_metric_process_resident_memory_bytes.value) measures the resident memory bytes used by the Kubelet process. This provides insights into the current memory usage footprint of the Kubelet service.
k8s.kubelet.rest_client.request_duration_seconds.histogram The metric k8s.kubelet.rest_client.request_duration_seconds.histogram (formerly known as ed_k8s_metric_rest_client_request_duration_seconds.histogram) captures the distribution of the request duration in seconds for rest client calls within the Kubelet. This helps in understanding latency characteristics of these requests.
k8s.kubelet.rest_client.requests.rate The metric k8s.kubelet.rest_client.requests.rate (formerly known as ed_k8s_metric_rest_client_requests.rate) captures the rate of requests made by the rest client in the Kubelet. This helps in monitoring the request load handled by the Kubelet.
k8s.kubelet.rest_client.requests.value The metric k8s.kubelet.rest_client.requests.value (formerly known as ed_k8s_metric_rest_client_requests.value) represents the total number of requests made by the Kubelet’s REST client. This metric is useful for monitoring request activity within the Kubelet.
k8s.kubelet.running_containers.value The metric k8s.kubelet.running_containers.value (formerly known as ed_k8s_metric_kubelet_running_containers.value) represents the number of running containers managed by the Kubelet. This metric helps monitor the status and count of active containers under Kubelet’s management.
k8s.kubelet.running_pods.value The metric k8s.kubelet.running_pods.value (formerly known as ed_k8s_metric_kubelet_running_pods.value) represents the count of pods currently running under the management of the Kubelet. This is useful for monitoring the operational status of pods in the Kubernetes environment.
k8s.kubelet.runtime.operations_errors.rate The metric k8s.kubelet.runtime.operations_errors.rate (formerly known as ed_k8s_metric_kubelet_runtime_operations_errors.rate) measures the rate of errors in runtime operations handled by the Kubelet. This metric is essential for detecting and monitoring operational errors within Kubelet’s runtime processes.
k8s.kubelet.runtime.operations_errors.value The metric k8s.kubelet.runtime.operations_errors.value (formerly known as ed_k8s_metric_kubelet_runtime_operations_errors.value) measures the total number of errors encountered in runtime operations by the Kubelet. This provides insights into the reliability and error frequency in Kubelet’s operations.
k8s.kubelet.runtime.operations.rate The metric k8s.kubelet.runtime.operations.rate (formerly known as ed_k8s_metric_kubelet_runtime_operations.rate) captures the rate of runtime operations handled by the Kubelet. This metric provides insights into the operational throughput managed by the Kubelet.
k8s.kubelet.runtime.operations.value The metric k8s.kubelet.runtime.operations.value (formerly known as ed_k8s_metric_kubelet_runtime_operations.value) represents the total number of runtime operations performed by the Kubelet. This provides insights into the activity level of Kubelet’s operations.
k8s.kubelet.volume_manager.total_volumes.value The metric k8s.kubelet.volume_manager.total_volumes.value (formerly known as ed_k8s_metric_volume_manager_total_volumes.value) indicates the total number of volumes managed by the Kubelet’s volume manager. This metric is important for monitoring storage utilization and volume management within the Kubernetes environment.

cAdvisor Metrics

Metric Definition
k8s.container.cpu.usage_seconds.rate The metric k8s.container.cpu.usage_seconds.rate (formerly known as ed_k8s_metric_container_cpu_usage_seconds.rate) measures the rate of CPU seconds used by containers. This metric is crucial for monitoring container CPU usage within the Kubernetes environment.
k8s.container.cpu.usage_seconds.value The metric k8s.container.cpu.usage_seconds.value (formerly known as ed_k8s_metric_container_cpu_usage_seconds.value) captures the total CPU time consumed by a container in seconds. This metric is crucial for monitoring CPU usage and performance of containers.
k8s.container.memory.usage_bytes.value The metric k8s.container.memory.usage_bytes.value (formerly known as ed_k8s_metric_container_memory_usage_bytes.value) measures the memory usage in bytes by a container. This is essential for tracking container memory consumption within Kubernetes environments.
k8s.container.network.receive_bytes.rate The metric k8s.container.network.receive_bytes.rate (formerly known as ed_k8s_metric_container_network_receive_bytes.rate) measures the rate at which bytes are received over the network by a container. This metric helps to understand the network input activity for containers.
k8s.container.network.receive_bytes.value The metric k8s.container.network.receive_bytes.value (formerly known as ed_k8s_metric_container_network_receive_bytes.value) measures the total bytes received over the network by a container. This metric is essential for monitoring network input traffic to containers.
k8s.container.network.receive_errors.rate The metric k8s.container.network.receive_errors.rate (formerly known as ed_k8s_metric_container_network_receive_errors.rate) captures the rate of errors encountered while receiving network data by the container. This metric provides insights into the network reliability and error frequency for received data packets.
k8s.container.network.receive_errors.value The metric k8s.container.network.receive_errors.value (formerly known as ed_k8s_metric_container_network_receive_errors.value) tracks the total number of errors encountered while receiving network data by the container. This metric helps in evaluating the reliability of network traffic received.
k8s.container.network.transmit_bytes.rate The metric k8s.container.network.transmit_bytes.rate (formerly known as ed_k8s_metric_container_network_transmit_bytes.rate) measures the rate at which bytes are transmitted from the container over the network. This helps monitor network output activity for containers.
k8s.container.network.transmit_bytes.value The metric k8s.container.network.transmit_bytes.value (formerly known as ed_k8s_metric_container_network_transmit_bytes.value) measures the total number of bytes transmitted from a container over the network. This metric is important for assessing the network output traffic of containers.
k8s.container.network.transmit_errors.rate The metric k8s.container.network.transmit_errors.rate (formerly known as ed_k8s_metric_container_network_transmit_errors.rate) measures the rate of errors occurring when a container transmits data over the network. This metric helps in identifying reliability issues with container network transmissions.
k8s.container.network.transmit_errors.value The metric k8s.container.network.transmit_errors.value (formerly known as ed_k8s_metric_container_network_transmit_errors.value) tracks the total number of errors encountered while transmitting network data from a container. This metric helps evaluate the reliability of network outputs.

Node Exporter Metrics

Metric Definition
k8s.node.cpu.seconds.rate The metric k8s.node.cpu.seconds.rate (formerly known as ed_k8s_metric_node_cpu_seconds.rate) measures the rate of CPU seconds used by the node. This is important for tracking the CPU usage across the entire node in Kubernetes.
k8s.node.cpu.seconds.value The metric k8s.node.cpu.seconds.value (formerly known as ed_k8s_metric_node_cpu_seconds.value) measures the total CPU time consumed by the node, expressed in seconds. This metric is essential for understanding the overall CPU resource usage of the node.
k8s.node.filesystem.avail_bytes.value The metric k8s.node.filesystem.avail_bytes.value (formerly known as ed_k8s_metric_node_filesystem_avail_bytes.value) tracks the available filesystem bytes on a node. This metric indicates how much storage space is left for use.
k8s.node.filesystem.size_bytes.value The metric k8s.node.filesystem.size_bytes.value (formerly known as ed_k8s_metric_node_filesystem_size_bytes.value) measures the total size of the filesystem in bytes on a node. This provides insights into the total storage capacity available on the node.
k8s.node.load.15min.value The metric k8s.node.load.15min.value (formerly known as ed_k8s_metric_node_load15.value) measures the 15-minute average load on a Kubernetes node. This metric provides insight into the node’s load and processing demand over a 15-minute interval, which can help identify periods of high computational demand or average system load in the context of Kubernetes clusters.
k8s.node.memory.available_bytes.value The metric k8s.node.memory.available_bytes.value (formerly known as ed_k8s_metric_node_memory_mem_available_bytes.value) tracks the amount of available memory on a Kubernetes node in bytes. This metric is vital for monitoring memory availability, ensuring that sufficient memory resources are allocated for applications running on the node.
k8s.node.memory.total_bytes.value The metric k8s.node.memory.total_bytes.value (formerly known as ed_k8s_metric_node_memory_mem_total_bytes.value) measures the total memory capacity of a Kubernetes node in bytes. This metric is crucial for understanding the physical memory resources available on the node, helping to ensure proper memory management and allocation across the cluster.
k8s.node.network.receive_bytes.rate The metric k8s.node.network.receive_bytes.rate (formerly known as ed_k8s_metric_node_network_receive_bytes.rate) measures the rate at which bytes are received on a network interface of a Kubernetes node. This metric is essential for monitoring network traffic and understanding network bandwidth utilization to ensure the node’s network capacity is not exceeded.
k8s.node.network.receive_bytes.value The metric k8s.node.network.receive_bytes.value (formerly known as ed_k8s_metric_node_network_receive_bytes.value) represents the total bytes received on a network interface of a Kubernetes node. This metric is important for evaluating the overall network traffic and bandwidth usage on the node, which helps in managing network performance and capacity planning.
k8s.node.network.transmit_bytes.rate The metric k8s.node.network.transmit_bytes.rate (formerly known as ed_k8s_metric_node_network_transmit_bytes.rate) measures the rate at which bytes are transmitted on a network interface of a Kubernetes node. This metric is crucial for understanding outbound network traffic and helps in monitoring network performance to ensure sufficient network capacity.
k8s.node.network.transmit_bytes.value The metric k8s.node.network.transmit_bytes.value (formerly known as ed_k8s_metric_node_network_transmit_bytes.value) represents the total bytes transmitted from a network interface of a Kubernetes node. This metric is important for assessing the total outbound network traffic from the node, aiding in the management of network throughput and bandwidth usage.

Kube-state Metrics

Metric Definition
k8s.ksm.cronjob_info.value The metric k8s.ksm.cronjob_info.value (formerly known as ed_k8s_metric_kube_cronjob_info.value) indicates the presence of a Kubernetes cron job. This metric is crucial for counting the number of cron jobs defined within the Kubernetes cluster.
k8s.ksm.daemonset_metadata_generation.value The metric k8s.ksm.daemonset_metadata_generation.value (formerly known as ed_k8s_metric_kube_daemonset_metadata_generation.value) provides the generation number for a Kubernetes DaemonSet, which reflects the version of its desired state specification. This is useful for tracking updates and consistency within DaemonSet specifications.
k8s.ksm.deployment_metadata_generation.value The metric k8s.ksm.deployment_metadata_generation.value (formerly known as ed_k8s_metric_kube_deployment_metadata_generation.value) indicates the metadata generation number for a Kubernetes Deployment. This metric helps track the version of the deployment’s configuration, which can be useful for detecting configuration changes and ensuring deployment consistency.
k8s.ksm.deployment.status_replicas_available.value The metric k8s.ksm.deployment.status_replicas_available.value (formerly known as ed_k8s_metric_kube_deployment_status_replicas_available.value) indicates the number of available replicas for a Kubernetes Deployment. This metric helps in monitoring the deployment to ensure the desired number of pods are up and running successfully.
k8s.ksm.job_info.value The metric k8s.ksm.job_info.value (formerly known as ed_k8s_metric_kube_job_info.value) provides the count of Kubernetes jobs. This metric is important for tracking the number of jobs running in the Kubernetes cluster.
k8s.ksm.namespace.status_phase.value The metric k8s.ksm.namespace.status_phase.value (formerly known as ed_k8s_metric_kube_namespace_status_phase.value) indicates the phase of a Kubernetes namespace. This metric helps in determining the operational status of namespaces within a Kubernetes cluster.
k8s.ksm.node.info.value The metric k8s.ksm.node.info.value (formerly known as ed_k8s_metric_kube_node_info.value) provides the count of Kubernetes nodes. This metric is useful for tracking the total number of nodes present in the Kubernetes cluster.
k8s.ksm.pod.container_resource_limits_cpu.value The metric k8s.ksm.pod.container_resource_limits_cpu.value (formerly known as ed_k8s_metric_kube_pod_container_resource_limits_cpu.value) indicates the CPU resource limit set for a container within a Kubernetes pod. This metric helps in managing and enforcing the maximum CPU resources that the container can utilize.
k8s.ksm.pod.container_resource_limits_memory.value The metric k8s.ksm.pod.container_resource_limits_memory.value (formerly known as ed_k8s_metric_kube_pod_container_resource_limits_memory.value) indicates the memory resource limit set for a container within a Kubernetes pod. This metric helps in managing and enforcing the maximum memory resources that the container can utilize.
k8s.ksm.pod.container_resource_requests_cpu.value The metric k8s.ksm.pod.container_resource_requests_cpu.value (formerly known as ed_k8s_metric_kube_pod_container_resource_requests_cpu.value) indicates the CPU resources requested for a container within a Kubernetes pod. This metric assists in monitoring and ensuring the minimum CPU resources that the container is expected to utilize are adequately set.
k8s.ksm.pod.container_resource_requests_memory.value The metric k8s.ksm.pod.container_resource_requests_memory.value (formerly known as ed_k8s_metric_kube_pod_container_resource_requests_memory.value) indicates the memory resources requested for a container within a Kubernetes pod. This metric is important for monitoring and ensuring the minimum memory resources expected for container operation are available.
k8s.ksm.pod.container_status_running.value The metric k8s.ksm.pod.container_status_running.value (formerly known as ed_k8s_metric_kube_pod_container_status_running.value) indicates whether containers within Kubernetes pods are running. This metric helps ensure that the expected number of containers are actively running in the cluster.
k8s.ksm.pod.container_status_terminated.value The metric k8s.ksm.pod.container_status_terminated.value (formerly known as ed_k8s_metric_kube_pod_container_status_terminated.value) indicates whether containers within Kubernetes pods are terminated. This metric helps track the number of containers that have completed execution or stopped running in the cluster.
k8s.ksm.pod.container_status_waiting.value The metric k8s.ksm.pod.container_status_waiting.value (formerly known as ed_k8s_metric_kube_pod_container_status_waiting.value) indicates the number of containers within Kubernetes pods that are in a waiting state. This metric is important for understanding how many containers are unable to progress to a running state, which could suggest resource bottlenecks or configuration issues.
k8s.ksm.pod.status_phase.value The metric k8s.ksm.pod.status_phase.value (formerly known as ed_k8s_metric_kube_pod_status_phase.value) indicates the different phases of Kubernetes pods, which include Pending, Running, Succeeded, Failed, and Unknown. This metric is valuable for understanding the lifecycle stages of pods within the Kubernetes cluster.
k8s.ksm.statefulset_metadata_generation.value The metric k8s.ksm.statefulset_metadata_generation.value (formerly known as ed_k8s_metric_kube_statefulset_metadata_generation.value) reflects the generation number of a Kubernetes StatefulSet’s metadata. This is used to track updates and changes to the StatefulSet’s configuration in the cluster.

Traffic Metrics

Metric Definition
k8s.traffic.communication.count The metric k8s.traffic.communication.count (formerly known as ed_k8s_traffic_communication.count) provides a count of network communications or transactions occurring within a Kubernetes environment. This metric helps in tracking the volume of communication traffic between Kubernetes components.
k8s.traffic.communication.latency.avg The metric k8s.traffic.communication.latency.avg (formerly known as ed_k8s_traffic_latency.avg) measures the average latency of communication events occurring within a Kubernetes environment. This metric is crucial for analyzing the performance and responsiveness of inter-component communications.
k8s.traffic.communication.latency.p95 The metric k8s.traffic.communication.latency.p95 (formerly known as ed_k8s_traffic_latency.p95) measures the 95th percentile communication latency within a Kubernetes environment. This metric is useful for analyzing tail-end latency and identifying potential bottlenecks or delays affecting a small percentage of communication interactions.
k8s.traffic.communication.read_bytes.sum The metric k8s.traffic.communication.read_bytes.sum (formerly known as ed_k8s_traffic_in.sum) measures the total bytes read or inbound traffic within a Kubernetes environment. This metric is important for assessing the volume of incoming network data and understanding network usage patterns.
k8s.traffic.communication.write_bytes.sum The metric k8s.traffic.communication.write_bytes.sum (formerly known as ed_k8s_traffic_out.sum) measures the total bytes written or outbound traffic within a Kubernetes environment. This metric is important for assessing the volume of outgoing network data and understanding network usage patterns.