/// <inheritdoc/>
        protected override async Task ReportMetrics(object component)
        {
            await Task.Factory.StartNew(() =>
            {
                var clusterComponent = (ClusterHostComponent)component;

                // Constructing labels
                var labels = new Dictionary <string, string>()
                {
                    { "ClusterName", clusterComponent.HostDetails.ClusterName },
                    { "Component", $"Hosts/{clusterComponent.HostDetails.HostName}" },
                };
                labels.TryAdd(_hostConfiguration.DefaultLabels);

                // Disk
                PrometheusUtils.ReportGauge(Collectors, "Disk_Free", clusterComponent.Metrics.Disk.Free, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadBytes", clusterComponent.Metrics.Disk.ReadBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadCount", clusterComponent.Metrics.Disk.ReadCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadTime", clusterComponent.Metrics.Disk.ReadTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_Disk", clusterComponent.Metrics.Disk.Total, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteBytes", clusterComponent.Metrics.Disk.WriteBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteCount", clusterComponent.Metrics.Disk.WriteCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteTime", clusterComponent.Metrics.Disk.WriteTime, labels);

                // Cpu
                PrometheusUtils.ReportGauge(Collectors, "HostCpu_Idle", clusterComponent.Metrics.HostCpu.Idle, labels);
                PrometheusUtils.ReportGauge(Collectors, "HostCpu_Nice", clusterComponent.Metrics.HostCpu.Nice, labels);
                PrometheusUtils.ReportGauge(Collectors, "HostCpu_Num", clusterComponent.Metrics.HostCpu.Num, labels);
                PrometheusUtils.ReportGauge(Collectors, "HostCpu_System", clusterComponent.Metrics.HostCpu.System, labels);
                PrometheusUtils.ReportGauge(Collectors, "HostCpu_User", clusterComponent.Metrics.HostCpu.User, labels);
                PrometheusUtils.ReportGauge(Collectors, "HostCpu_Wio", clusterComponent.Metrics.HostCpu.Wio, labels);

                // Memory
                PrometheusUtils.ReportGauge(Collectors, "Memory_CachedKb", clusterComponent.Metrics.Memory.CachedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_FreeKb", clusterComponent.Metrics.Memory.FreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_Critical", clusterComponent.Metrics.Memory.SharedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SwapFreeKb", clusterComponent.Metrics.Memory.SwapFreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_TotalKb", clusterComponent.Metrics.Memory.TotalKb, labels);

                // Network
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesIn", clusterComponent.Metrics.Network.BytesIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesOut", clusterComponent.Metrics.Network.BytesOut, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsIn", clusterComponent.Metrics.Network.PktsIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsOut", clusterComponent.Metrics.Network.PktsOut, labels);

                // Processes
                PrometheusUtils.ReportGauge(Collectors, "Process_Run", clusterComponent.Metrics.Process.Run, labels);
                PrometheusUtils.ReportGauge(Collectors, "Process_Total", clusterComponent.Metrics.Process.Total, labels);
            });
        }
        /// <summary>
        /// Internal method used to extract queue metrics by queue name.
        /// </summary>
        /// <param name="queue">Queue object</param>
        /// <param name="labels">Additional labels</param>
        internal void ReportQueueMetrics(Queue queue, Dictionary <string, string> labels)
        {
            // Constructing labels
            var localLabels = new Dictionary <string, string>()
            {
                { "QueueName", queue.Name },
            };

            localLabels.TryAdd(labels);

            PrometheusUtils.ReportGauge(Collectors, "Queue_AMResourceLimitMB", queue.AMResourceLimitMB, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AMResourceLimitVCores", queue.AMResourceLimitVCores, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_ActiveApplications", queue.ActiveApplications, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_ActiveUsers", queue.ActiveUsers, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AggregateContainersAllocated", queue.AggregateContainersAllocated, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AggregateContainersReleased", queue.AggregateContainersReleased, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AllocatedContainers", queue.AllocatedContainers, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AllocatedMB", queue.AllocatedMB, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AllocatedVCores", queue.AllocatedVCores, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppAttemptFirstContainerAllocationDelayAvgTime", queue.AppAttemptFirstContainerAllocationDelayAvgTime, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppAttemptFirstContainerAllocationDelayNumOps", queue.AppAttemptFirstContainerAllocationDelayNumOps, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppsCompleted", queue.AppsCompleted, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppsFailed", queue.AppsFailed, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppsKilled", queue.AppsKilled, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppsPending", queue.AppsPending, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppsRunning", queue.AppsRunning, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AppsSubmitted", queue.AppsSubmitted, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AvailableMB", queue.AvailableMB, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_AvailableVCores", queue.AvailableVCores, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_PendingContainers", queue.PendingContainers, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_PendingMB", queue.PendingMB, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_PendingVCores", queue.PendingVCores, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_ReservedContainers", queue.ReservedContainers, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_ReservedMB", queue.ReservedMB, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_ReservedVCores", queue.ReservedVCores, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_UsedAMResourceMB", queue.UsedAMResourceMB, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_UsedAMResourceVCores", queue.UsedAMResourceVCores, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_Running0", queue.Running0, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_Running1440", queue.Running1440, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_Running300", queue.Running300, localLabels);
            PrometheusUtils.ReportGauge(Collectors, "Queue_Running60", queue.Running60, localLabels);
        }
        /// <inheritdoc/>
        protected override async Task ReportMetrics(object component)
        {
            var clusterComponent = (ClusterComponent)component;
            var hostsTasksList   = ExportHostsMetricsAsync(clusterComponent.HostEntryList);

            // Constructing labels
            var labels = new Dictionary <string, string>()
            {
                { "ClusterName", clusterComponent.ClusterReport.ClusterName },
                { "Component", "Cluster" },
            };

            labels.TryAdd(_clusterConfiguration.DefaultLabels);

            // Health Report
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HeartbeatLost", clusterComponent.ClusterReport.HealthReport.HeartbeatLost, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsStateHealthy", clusterComponent.ClusterReport.HealthReport.HostsStateHealthy, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsStateHealthy", clusterComponent.ClusterReport.HealthReport.HostsStateUnhealthy, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsStatusAlert", clusterComponent.ClusterReport.HealthReport.HostsStatusAlert, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsStatusHealthy", clusterComponent.ClusterReport.HealthReport.HostsStatusHealthy, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsStatusUnhealthy", clusterComponent.ClusterReport.HealthReport.HostsStatusUnhealthy, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsStatusUnknown", clusterComponent.ClusterReport.HealthReport.HostsStatusUnknown, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsWithMaintenanceFlag", clusterComponent.ClusterReport.HealthReport.HostsWithMaintenanceFlag, labels);
            PrometheusUtils.ReportGauge(Collectors, "HealthReport_HostsWithStaleConfig", clusterComponent.ClusterReport.HealthReport.HostsWithStaleConfig, labels);

            // Alerts Summary
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummary_Critical", clusterComponent.AlertsSummary.Critical, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummary_Maintenance", clusterComponent.AlertsSummary.Maintenance, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummary_Ok", clusterComponent.AlertsSummary.Ok, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummary_Unknown", clusterComponent.AlertsSummary.Unknown, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummary_Warning", clusterComponent.AlertsSummary.Warning, labels);

            // Alerts Summary Hosts
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummaryHosts_Critical", clusterComponent.AlertsSummaryHosts.Critical, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummaryHosts_Ok", clusterComponent.AlertsSummaryHosts.Ok, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummaryHosts_Unknown", clusterComponent.AlertsSummaryHosts.Unknown, labels);
            PrometheusUtils.ReportGauge(Collectors, "AlertsSummaryHosts_Warning", clusterComponent.AlertsSummaryHosts.Warning, labels);

            // Waiting for hosts
            await Task.WhenAll(hostsTasksList);
        }
        /// <inheritdoc/>
        protected override async Task ReportMetrics(object component)
        {
            await Task.Factory.StartNew(() =>
            {
                var resourceManagerComponent = (ResourceManagerComponent)component;

                // Constructing labels
                var labels = new Dictionary <string, string>()
                {
                    { "ClusterName", resourceManagerComponent.Info.ClusterName },
                    { "Component", resourceManagerComponent.Info.ComponentName },
                };
                labels.TryAdd(_exporterConfiguration.DefaultLabels);

                // General info
                PrometheusUtils.ReportGauge(Collectors, "Info_StartTime", resourceManagerComponent.Info.StartTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_StartedCount", resourceManagerComponent.Info.StartedCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_TotalCount", resourceManagerComponent.Info.TotalCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_UnknownCount", resourceManagerComponent.Info.UnknownCount, labels);

                // Yarn queues
                ReportQueueMetrics(resourceManagerComponent.Metrics.YarnMetrics.Queues.Root, labels);
                foreach (var queue in resourceManagerComponent.Metrics.YarnMetrics.Queues.Root.GetChildrenQueuesIEnumerable())
                {
                    ReportQueueMetrics(queue, labels);
                }

                // Node Manager
                PrometheusUtils.ReportGauge(Collectors, "NumActiveNMs", resourceManagerComponent.Metrics.YarnMetrics.YarnResourceManagerClusterMetrics.NumActiveNMs, labels);
                PrometheusUtils.ReportGauge(Collectors, "NumDecommissionedNMs", resourceManagerComponent.Metrics.YarnMetrics.YarnResourceManagerClusterMetrics.NumDecommissionedNMs, labels);
                PrometheusUtils.ReportGauge(Collectors, "NumLostNMs", resourceManagerComponent.Metrics.YarnMetrics.YarnResourceManagerClusterMetrics.NumLostNMs, labels);
                PrometheusUtils.ReportGauge(Collectors, "NumRebootedNMs", resourceManagerComponent.Metrics.YarnMetrics.YarnResourceManagerClusterMetrics.NumRebootedNMs, labels);
                PrometheusUtils.ReportGauge(Collectors, "NumUnhealthyNMs", resourceManagerComponent.Metrics.YarnMetrics.YarnResourceManagerClusterMetrics.NumUnhealthyNMs, labels);

                // HdfsNameNodeJvm
                PrometheusUtils.ReportGauge(Collectors, "Jvm_HeapMemoryMax", resourceManagerComponent.Metrics.ResourceManagerJvm.HeapMemoryMax, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_HeapMemoryUsed", resourceManagerComponent.Metrics.ResourceManagerJvm.HeapMemoryUsed, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_NonHeapMemoryMax", resourceManagerComponent.Metrics.ResourceManagerJvm.NonHeapMemoryMax, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_NonHeapMemoryUsed", resourceManagerComponent.Metrics.ResourceManagerJvm.NonHeapMemoryUsed, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_GcCount", resourceManagerComponent.Metrics.ResourceManagerJvm.GcCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_GcTimeMillis", resourceManagerComponent.Metrics.ResourceManagerJvm.GcTimeMillis, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_LogError", resourceManagerComponent.Metrics.ResourceManagerJvm.LogError, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_LogFatal", resourceManagerComponent.Metrics.ResourceManagerJvm.LogFatal, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_LogInfo", resourceManagerComponent.Metrics.ResourceManagerJvm.LogInfo, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_LogWarn", resourceManagerComponent.Metrics.ResourceManagerJvm.LogWarn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemHeapCommittedM", resourceManagerComponent.Metrics.ResourceManagerJvm.MemHeapCommittedM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemHeapUsedMB", resourceManagerComponent.Metrics.ResourceManagerJvm.MemHeapUsedMB, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemMaxMB", resourceManagerComponent.Metrics.ResourceManagerJvm.MemMaxMB, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemNonHeapCommittedMB", resourceManagerComponent.Metrics.ResourceManagerJvm.MemNonHeapCommittedMB, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemNonHeapUsedMB", resourceManagerComponent.Metrics.ResourceManagerJvm.MemNonHeapUsedMB, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_ThreadsBlocked", resourceManagerComponent.Metrics.ResourceManagerJvm.ThreadsBlocked, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_ThreadsNew", resourceManagerComponent.Metrics.ResourceManagerJvm.ThreadsNew, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_ThreadsRunnable", resourceManagerComponent.Metrics.ResourceManagerJvm.ThreadsRunnable, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_ThreadsTerminated", resourceManagerComponent.Metrics.ResourceManagerJvm.ThreadsTerminated, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_ThreadsTimedWaiting", resourceManagerComponent.Metrics.ResourceManagerJvm.ThreadsTimedWaiting, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_ThreadsWaiting", resourceManagerComponent.Metrics.ResourceManagerJvm.ThreadsWaiting, labels);

                // YarnResourceManagerRpc
                PrometheusUtils.ReportGauge(Collectors, "Rpc_NumOpenConnections", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.NumOpenConnections, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_ReceivedBytes", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.ReceivedBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcProcessingTime_avg_time", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcProcessingTime_avg_time, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcProcessingTime_num_ops", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcProcessingTime_num_ops, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcQueueTime_avg_time", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcQueueTime_avg_time, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcQueueTime_num_ops", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcQueueTime_num_ops, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_SentBytes", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.SentBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_CallQueueLen", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.CallQueueLen, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcAuthenticationFailures", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcAuthenticationFailures, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcAuthenticationSuccesses", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcAuthenticationSuccesses, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcAuthorizationFailures", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcAuthorizationFailures, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_RpcAuthorizationSuccesses", resourceManagerComponent.Metrics.ResourceManagerYarnResourceManagerRpc.RpcAuthorizationSuccesses, labels);

                // Runtime
                PrometheusUtils.ReportGauge(Collectors, "Runtime_StartTime", resourceManagerComponent.Metrics.Runtime.StartTime, labels);

                // Ugi
                PrometheusUtils.ReportGauge(Collectors, "Ugi_LoginFailure_avg_time", resourceManagerComponent.Metrics.Ugi.LoginFailure_avg_time, labels);
                PrometheusUtils.ReportGauge(Collectors, "Ugi_LoginFailure_num_ops", resourceManagerComponent.Metrics.Ugi.LoginFailure_num_ops, labels);
                PrometheusUtils.ReportGauge(Collectors, "Ugi_LoginSuccess_avg_time", resourceManagerComponent.Metrics.Ugi.LoginSuccess_avg_time, labels);
                PrometheusUtils.ReportGauge(Collectors, "Ugi_LoginSuccess_num_ops", resourceManagerComponent.Metrics.Ugi.LoginSuccess_num_ops, labels);
            });
        }
예제 #5
0
        /// <inheritdoc/>
        protected override async Task ReportMetrics(object component)
        {
            await Task.Factory.StartNew(() =>
            {
                var nodeManagerComponent = (NodeManagerComponent)component;

                // Constructing labels
                var labels = new Dictionary <string, string>()
                {
                    { "ClusterName", nodeManagerComponent.Info.ClusterName },
                    { "Component", nodeManagerComponent.Info.ComponentName },
                };
                labels.TryAdd(_exporterConfiguration.DefaultLabels);

                // General info
                PrometheusUtils.ReportGauge(Collectors, "Info_StartTime", nodeManagerComponent.Info.StartTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_StartedCount", nodeManagerComponent.Info.StartedCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_TotalCount", nodeManagerComponent.Info.TotalCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_UnknownCount", nodeManagerComponent.Info.UnknownCount, labels);

                // Yarn related
                PrometheusUtils.ReportGauge(Collectors, "AllocatedContainers", nodeManagerComponent.Metrics.YarnBase.AllocatedContainers, labels);
                PrometheusUtils.ReportGauge(Collectors, "AllocatedGB", nodeManagerComponent.Metrics.YarnBase.AllocatedGB, labels);
                PrometheusUtils.ReportGauge(Collectors, "AllocatedVCores", nodeManagerComponent.Metrics.YarnBase.AllocatedVCores, labels);
                PrometheusUtils.ReportGauge(Collectors, "ContainersCompleted", nodeManagerComponent.Metrics.YarnBase.ContainersCompleted, labels);
                PrometheusUtils.ReportGauge(Collectors, "ContainersFailed", nodeManagerComponent.Metrics.YarnBase.ContainersFailed, labels);
                PrometheusUtils.ReportGauge(Collectors, "ContainersIniting", nodeManagerComponent.Metrics.YarnBase.ContainersIniting, labels);
                PrometheusUtils.ReportGauge(Collectors, "ContainersKilled", nodeManagerComponent.Metrics.YarnBase.ContainersKilled, labels);
                PrometheusUtils.ReportGauge(Collectors, "ContainersLaunched", nodeManagerComponent.Metrics.YarnBase.ContainersLaunched, labels);
                PrometheusUtils.ReportGauge(Collectors, "ContainersRunning", nodeManagerComponent.Metrics.YarnBase.ContainersRunning, labels);

                // Cpu
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Idle", nodeManagerComponent.Metrics.Cpu.Idle, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Nice", nodeManagerComponent.Metrics.Cpu.Nice, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_System", nodeManagerComponent.Metrics.Cpu.System, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_User", nodeManagerComponent.Metrics.Cpu.User, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Wio", nodeManagerComponent.Metrics.Cpu.Wio, labels);

                // Disk
                PrometheusUtils.ReportGauge(Collectors, "Disk_Free", nodeManagerComponent.Metrics.Disk.Free, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadBytes", nodeManagerComponent.Metrics.Disk.ReadBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadCount", nodeManagerComponent.Metrics.Disk.ReadCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadTime", nodeManagerComponent.Metrics.Disk.ReadTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_Total", nodeManagerComponent.Metrics.Disk.Total, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteBytes", nodeManagerComponent.Metrics.Disk.WriteBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteCount", nodeManagerComponent.Metrics.Disk.WriteCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteTime", nodeManagerComponent.Metrics.Disk.WriteTime, labels);

                // Memory
                PrometheusUtils.ReportGauge(Collectors, "Memory_CachedKb", nodeManagerComponent.Metrics.Memory.CachedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_FreeKb", nodeManagerComponent.Metrics.Memory.FreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SharedKb", nodeManagerComponent.Metrics.Memory.SharedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SwapFreeKb", nodeManagerComponent.Metrics.Memory.SwapFreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_TotalKb", nodeManagerComponent.Metrics.Memory.TotalKb, labels);

                // Network
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesIn", nodeManagerComponent.Metrics.Network.BytesIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesOut", nodeManagerComponent.Metrics.Network.BytesOut, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsIn", nodeManagerComponent.Metrics.Network.PktsIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsOut", nodeManagerComponent.Metrics.Network.PktsOut, labels);

                // Process
                PrometheusUtils.ReportGauge(Collectors, "Process_Run", nodeManagerComponent.Metrics.Process.Run, labels);
                PrometheusUtils.ReportGauge(Collectors, "Process_Total", nodeManagerComponent.Metrics.Process.Total, labels);
            });
        }
        /// <inheritdoc/>
        protected override async Task ReportMetrics(object component)
        {
            await Task.Factory.StartNew(() =>
            {
                var hdfsNameNodeComponent = (HdfsNameNodeComponent)component;

                // Constructing labels
                var labels = new Dictionary <string, string>()
                {
                    { "ClusterName", hdfsNameNodeComponent.Info.ClusterName },
                    { "Component", hdfsNameNodeComponent.Info.ComponentName },
                };
                labels.TryAdd(_exporterConfiguration.DefaultLabels);

                // General info
                PrometheusUtils.ReportGauge(Collectors, "Info_StartTime", hdfsNameNodeComponent.Info.StartTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_StartedCount", hdfsNameNodeComponent.Info.StartedCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_TotalCount", hdfsNameNodeComponent.Info.TotalCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_UnknownCount", hdfsNameNodeComponent.Info.UnknownCount, labels);

                // Cpu
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Idle", hdfsNameNodeComponent.Metrics.Cpu.Idle, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Nice", hdfsNameNodeComponent.Metrics.Cpu.Nice, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_System", hdfsNameNodeComponent.Metrics.Cpu.System, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_User", hdfsNameNodeComponent.Metrics.Cpu.User, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Wio", hdfsNameNodeComponent.Metrics.Cpu.Wio, labels);

                // HdfsDataNodeDfs - namenode
                PrometheusUtils.ReportGauge(
                    Collectors,
                    "CorruptFiles",
                    hdfsNameNodeComponent.Metrics.Dfs.NameNode.CorruptFiles.TrimStart('[').TrimEnd(']').Split(",", StringSplitOptions.RemoveEmptyEntries).Length,
                    labels);
                PrometheusUtils.ReportGauge(
                    Collectors,
                    "DeadNodes",
                    hdfsNameNodeComponent.Metrics.Dfs.NameNode.DeadNodes.TrimStart('{').TrimEnd('}').Split("},", StringSplitOptions.RemoveEmptyEntries).Length,
                    labels);
                PrometheusUtils.ReportGauge(
                    Collectors,
                    "DecomNodes",
                    hdfsNameNodeComponent.Metrics.Dfs.NameNode.DecomNodes.TrimStart('{').TrimEnd('}').Split("},", StringSplitOptions.RemoveEmptyEntries).Length,
                    labels);
                PrometheusUtils.ReportGauge(
                    Collectors,
                    "LiveNodes",
                    hdfsNameNodeComponent.Metrics.Dfs.NameNode.LiveNodes.TrimStart('[').TrimEnd(']').Split("},", StringSplitOptions.RemoveEmptyEntries).Length,
                    labels);
                PrometheusUtils.ReportGauge(Collectors, "Free", hdfsNameNodeComponent.Metrics.Dfs.NameNode.Free, labels);
                PrometheusUtils.ReportGauge(Collectors, "NonDfsUsedSpace", hdfsNameNodeComponent.Metrics.Dfs.NameNode.NonDfsUsedSpace, labels);
                PrometheusUtils.ReportGauge(Collectors, "PercentRemaining", hdfsNameNodeComponent.Metrics.Dfs.NameNode.PercentRemaining, labels);
                PrometheusUtils.ReportGauge(Collectors, "PercentUsed", hdfsNameNodeComponent.Metrics.Dfs.NameNode.PercentUsed, labels);
                PrometheusUtils.ReportGauge(Collectors, "Threads", hdfsNameNodeComponent.Metrics.Dfs.NameNode.Threads, labels);
                PrometheusUtils.ReportGauge(Collectors, "Total", hdfsNameNodeComponent.Metrics.Dfs.NameNode.Total, labels);
                PrometheusUtils.ReportGauge(Collectors, "TotalBlocks", hdfsNameNodeComponent.Metrics.Dfs.NameNode.TotalBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "TotalFiles", hdfsNameNodeComponent.Metrics.Dfs.NameNode.TotalFiles, labels);
                PrometheusUtils.ReportGauge(Collectors, "Used", hdfsNameNodeComponent.Metrics.Dfs.NameNode.Used, labels);

                // HdfsDataNodeDfs - system
                PrometheusUtils.ReportGauge(Collectors, "BlockCapacity", hdfsNameNodeComponent.Metrics.Dfs.System.BlockCapacity, labels);
                PrometheusUtils.ReportGauge(Collectors, "BlocksTotal", hdfsNameNodeComponent.Metrics.Dfs.System.BlocksTotal, labels);
                PrometheusUtils.ReportGauge(Collectors, "CapacityRemaining", hdfsNameNodeComponent.Metrics.Dfs.System.CapacityRemaining, labels);
                PrometheusUtils.ReportGauge(Collectors, "CapacityRemainingGB", hdfsNameNodeComponent.Metrics.Dfs.System.CapacityRemainingGB, labels);
                PrometheusUtils.ReportGauge(Collectors, "CapacityTotal", hdfsNameNodeComponent.Metrics.Dfs.System.CapacityTotal, labels);
                PrometheusUtils.ReportGauge(Collectors, "CapacityTotalGB", hdfsNameNodeComponent.Metrics.Dfs.System.CapacityTotalGB, labels);
                PrometheusUtils.ReportGauge(Collectors, "CapacityUsed", hdfsNameNodeComponent.Metrics.Dfs.System.CapacityUsed, labels);
                PrometheusUtils.ReportGauge(Collectors, "CapacityUsedGB", hdfsNameNodeComponent.Metrics.Dfs.System.CapacityUsedGB, labels);
                PrometheusUtils.ReportGauge(Collectors, "CorruptBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.CorruptBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "ExcessBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.ExcessBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "ExpiredHeartbeats", hdfsNameNodeComponent.Metrics.Dfs.System.ExpiredHeartbeats, labels);
                PrometheusUtils.ReportGauge(Collectors, "FilesTotal", hdfsNameNodeComponent.Metrics.Dfs.System.FilesTotal, labels);
                PrometheusUtils.ReportGauge(Collectors, "LastCheckpointTime", hdfsNameNodeComponent.Metrics.Dfs.System.LastCheckpointTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "LastWrittenTransactionId", hdfsNameNodeComponent.Metrics.Dfs.System.LastWrittenTransactionId, labels);
                PrometheusUtils.ReportGauge(Collectors, "MillisSinceLastLoadedEdits", hdfsNameNodeComponent.Metrics.Dfs.System.MillisSinceLastLoadedEdits, labels);
                PrometheusUtils.ReportGauge(Collectors, "MissingBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.MissingBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "MissingReplOneBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.MissingReplOneBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "PendingDataNodeMessageCount", hdfsNameNodeComponent.Metrics.Dfs.System.PendingDataNodeMessageCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "PendingDeletionBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.PendingDeletionBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "PendingReplicationBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.PendingReplicationBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "PostponedMisreplicatedBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.PostponedMisreplicatedBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "ScheduledReplicationBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.ScheduledReplicationBlocks, labels);
                PrometheusUtils.ReportGauge(Collectors, "Snapshots", hdfsNameNodeComponent.Metrics.Dfs.System.Snapshots, labels);
                PrometheusUtils.ReportGauge(Collectors, "SnapshottableDirectories", hdfsNameNodeComponent.Metrics.Dfs.System.SnapshottableDirectories, labels);
                PrometheusUtils.ReportGauge(Collectors, "StaleDataNodes", hdfsNameNodeComponent.Metrics.Dfs.System.StaleDataNodes, labels);
                PrometheusUtils.ReportGauge(Collectors, "TotalFiles", hdfsNameNodeComponent.Metrics.Dfs.System.TotalFiles, labels);
                PrometheusUtils.ReportGauge(Collectors, "TotalLoad", hdfsNameNodeComponent.Metrics.Dfs.System.TotalLoad, labels);
                PrometheusUtils.ReportGauge(Collectors, "TransactionsSinceLastCheckpoint", hdfsNameNodeComponent.Metrics.Dfs.System.TransactionsSinceLastCheckpoint, labels);
                PrometheusUtils.ReportGauge(Collectors, "TransactionsSinceLastLogRoll", hdfsNameNodeComponent.Metrics.Dfs.System.TransactionsSinceLastLogRoll, labels);
                PrometheusUtils.ReportGauge(Collectors, "UnderReplicatedBlocks", hdfsNameNodeComponent.Metrics.Dfs.System.UnderReplicatedBlocks, labels);

                // Disk
                PrometheusUtils.ReportGauge(Collectors, "Disk_Free", hdfsNameNodeComponent.Metrics.Disk.Free, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadBytes", hdfsNameNodeComponent.Metrics.Disk.ReadBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadCount", hdfsNameNodeComponent.Metrics.Disk.ReadCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadTime", hdfsNameNodeComponent.Metrics.Disk.ReadTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_Total", hdfsNameNodeComponent.Metrics.Disk.Total, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteBytes", hdfsNameNodeComponent.Metrics.Disk.WriteBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteCount", hdfsNameNodeComponent.Metrics.Disk.WriteCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteTime", hdfsNameNodeComponent.Metrics.Disk.WriteTime, labels);

                // HdfsNameNodeJvm
                PrometheusUtils.ReportGauge(Collectors, "Jvm_GcCountConcurrentMarkSweep", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.GcCountConcurrentMarkSweep, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_GcTimeMillisConcurrentMarkSweep", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.GcTimeMillisConcurrentMarkSweep, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_gcCount", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.GcCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_gcTimeMillis", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.GcTimeMillis, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_logError", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.LogError, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_logFatal", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.LogFatal, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_logInfo", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.LogInfo, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_logWarn", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.LogWarn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_memHeapCommittedM", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.MemHeapCommittedM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_memHeapUsedM", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.MemHeapUsedM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_memMaxM", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.MemMaxM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_memNonHeapCommittedM", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.MemNonHeapCommittedM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_memNonHeapUsedM", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.MemNonHeapUsedM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_threadsBlocked", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.ThreadsBlocked, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_threadsNew", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.ThreadsNew, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_threadsRunnable", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.ThreadsRunnable, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_threadsTerminated", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.ThreadsTerminated, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_threadsTimedWaiting", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.ThreadsTimedWaiting, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_threadsWaiting", hdfsNameNodeComponent.Metrics.HdfsNameNodeJvm.ThreadsWaiting, labels);

                // Memory
                PrometheusUtils.ReportGauge(Collectors, "Memory_CachedKb", hdfsNameNodeComponent.Metrics.Memory.CachedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_FreeKb", hdfsNameNodeComponent.Metrics.Memory.FreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SharedKb", hdfsNameNodeComponent.Metrics.Memory.SharedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SwapFreeKb", hdfsNameNodeComponent.Metrics.Memory.SwapFreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_TotalKb", hdfsNameNodeComponent.Metrics.Memory.TotalKb, labels);

                // Network
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesIn", hdfsNameNodeComponent.Metrics.Network.BytesIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesOut", hdfsNameNodeComponent.Metrics.Network.BytesOut, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsIn", hdfsNameNodeComponent.Metrics.Network.PktsIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsOut", hdfsNameNodeComponent.Metrics.Network.PktsOut, labels);

                // Process
                PrometheusUtils.ReportGauge(Collectors, "Process_Run", hdfsNameNodeComponent.Metrics.Process.Run, labels);
                PrometheusUtils.ReportGauge(Collectors, "Process_Total", hdfsNameNodeComponent.Metrics.Process.Total, labels);

                // YarnResourceManagerRpc
                PrometheusUtils.ReportGauge(Collectors, "Rpc_NumOpenConnections", hdfsNameNodeComponent.Metrics.Rpc.Client.NumOpenConnections, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_ReceivedBytes", hdfsNameNodeComponent.Metrics.Rpc.Client.ReceivedBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_ProcessingTimeAvgTime", hdfsNameNodeComponent.Metrics.Rpc.Client.ProcessingTimeAvgTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_QueueTimeAvgTime", hdfsNameNodeComponent.Metrics.Rpc.Client.QueueTimeAvgTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_SentBytes", hdfsNameNodeComponent.Metrics.Rpc.Client.SentBytes, labels);
            });
        }
        /// <inheritdoc/>
        protected override async Task ReportMetrics(object component)
        {
            await Task.Factory.StartNew(() =>
            {
                var hdfsDataNodeComponent = (HdfsDataNodeComponent)component;

                // Constructing labels
                var labels = new Dictionary <string, string>()
                {
                    { "ClusterName", hdfsDataNodeComponent.Info.ClusterName },
                    { "Component", hdfsDataNodeComponent.Info.ComponentName },
                };
                labels.TryAdd(_exporterConfiguration.DefaultLabels);

                // General info
                PrometheusUtils.ReportGauge(Collectors, "Info_StartedCount", hdfsDataNodeComponent.Info.StartedCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_TotalCount", hdfsDataNodeComponent.Info.TotalCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Info_UnknownCount", hdfsDataNodeComponent.Info.UnknownCount, labels);

                // HdfsDataNode
                PrometheusUtils.ReportGauge(Collectors, "Capacity", hdfsDataNodeComponent.Metrics.HdfsDataNodeDfs.HdfsDataNode.Capacity, labels);
                PrometheusUtils.ReportGauge(Collectors, "DfsUsed", hdfsDataNodeComponent.Metrics.HdfsDataNodeDfs.HdfsDataNode.DfsUsed, labels);
                PrometheusUtils.ReportGauge(Collectors, "NumFailedVolumes", hdfsDataNodeComponent.Metrics.HdfsDataNodeDfs.HdfsDataNode.NumFailedVolumes, labels);

                // Cpu
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Idle", hdfsDataNodeComponent.Metrics.Cpu.Idle, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Nice", hdfsDataNodeComponent.Metrics.Cpu.Nice, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_System", hdfsDataNodeComponent.Metrics.Cpu.System, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_User", hdfsDataNodeComponent.Metrics.Cpu.User, labels);
                PrometheusUtils.ReportGauge(Collectors, "Cpu_Wio", hdfsDataNodeComponent.Metrics.Cpu.Wio, labels);

                // HdfsDataNodeJvm
                PrometheusUtils.ReportGauge(Collectors, "Jvm_GcCount", hdfsDataNodeComponent.Metrics.DataNodeJvm.GcCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemHeapCommittedM", hdfsDataNodeComponent.Metrics.DataNodeJvm.MemHeapCommittedM, labels);
                PrometheusUtils.ReportGauge(Collectors, "Jvm_MemHeapUsedM", hdfsDataNodeComponent.Metrics.DataNodeJvm.MemHeapUsedM, labels);

                // YarnResourceManagerRpc
                PrometheusUtils.ReportGauge(Collectors, "Rpc_NumOpenConnections", hdfsDataNodeComponent.Metrics.DataNodeRpc.NumOpenConnections, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_ProcessingTimeAvgTime", hdfsDataNodeComponent.Metrics.DataNodeRpc.ProcessingTimeAvgTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Rpc_QueueTimeAvgTime", hdfsDataNodeComponent.Metrics.DataNodeRpc.QueueTimeAvgTime, labels);

                // Disk
                PrometheusUtils.ReportGauge(Collectors, "Disk_Free", hdfsDataNodeComponent.Metrics.Disk.Free, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadBytes", hdfsDataNodeComponent.Metrics.Disk.ReadBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadCount", hdfsDataNodeComponent.Metrics.Disk.ReadCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_ReadTime", hdfsDataNodeComponent.Metrics.Disk.ReadTime, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_Total", hdfsDataNodeComponent.Metrics.Disk.Total, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteBytes", hdfsDataNodeComponent.Metrics.Disk.WriteBytes, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteCount", hdfsDataNodeComponent.Metrics.Disk.WriteCount, labels);
                PrometheusUtils.ReportGauge(Collectors, "Disk_WriteTime", hdfsDataNodeComponent.Metrics.Disk.WriteTime, labels);

                // Memory
                PrometheusUtils.ReportGauge(Collectors, "Memory_CachedKb", hdfsDataNodeComponent.Metrics.Memory.CachedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_FreeKb", hdfsDataNodeComponent.Metrics.Memory.FreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SharedKb", hdfsDataNodeComponent.Metrics.Memory.SharedKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_SwapFreeKb", hdfsDataNodeComponent.Metrics.Memory.SwapFreeKb, labels);
                PrometheusUtils.ReportGauge(Collectors, "Memory_TotalKb", hdfsDataNodeComponent.Metrics.Memory.TotalKb, labels);

                // Network
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesIn", hdfsDataNodeComponent.Metrics.Network.BytesIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_BytesOut", hdfsDataNodeComponent.Metrics.Network.BytesOut, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsIn", hdfsDataNodeComponent.Metrics.Network.PktsIn, labels);
                PrometheusUtils.ReportGauge(Collectors, "Network_PktsOut", hdfsDataNodeComponent.Metrics.Network.PktsOut, labels);

                // Process
                PrometheusUtils.ReportGauge(Collectors, "Process_Run", hdfsDataNodeComponent.Metrics.Process.Run, labels);
                PrometheusUtils.ReportGauge(Collectors, "Process_Total", hdfsDataNodeComponent.Metrics.Process.Total, labels);
            });
        }
 public PrometheusUtilsTests()
 {
     _promtheusUtils = new PrometheusUtils();
 }