From ead7117cadb86aae8023aa854d07f164a7353720 Mon Sep 17 00:00:00 2001 From: Holger Obermaier <40787752+ho-ob@users.noreply.github.com> Date: Mon, 7 Feb 2022 13:30:01 +0100 Subject: [PATCH] Add skip_filesystem configuration --- collectors.json | 10 +- collectors/gpfsMetric.go | 287 ++++++++++++++++++++------------------- 2 files changed, 159 insertions(+), 138 deletions(-) diff --git a/collectors.json b/collectors.json index df2fce3..563ff05 100644 --- a/collectors.json +++ b/collectors.json @@ -1,4 +1,12 @@ { + "cpufreq": {}, + "cpufreq_cpuinfo": {}, + "gpfs": { + "exclude_filesystem": [ "test_fs" ] + }, + "loadavg": { + "exclude_metrics": [ "proc_total" ] + } "tempstat": { "tag_override": { "hwmon0" : { @@ -10,6 +18,4 @@ "type-id" : "1" } } - } - } diff --git a/collectors/gpfsMetric.go b/collectors/gpfsMetric.go index ffb2fac..adbc7fb 100644 --- a/collectors/gpfsMetric.go +++ b/collectors/gpfsMetric.go @@ -21,8 +21,10 @@ type GpfsCollector struct { metricCollector tags map[string]string config struct { - Mmpmon string `json:"mmpmon"` + Mmpmon string `json:"mmpmon_path,omitempty"` + ExcludeFilesystem []string `json:"exclude_filesystem,omitempty"` } + skipFS map[string]struct{} } func (m *GpfsCollector) Init(config json.RawMessage) error { @@ -54,6 +56,10 @@ func (m *GpfsCollector) Init(config json.RawMessage) error { "type": "node", "filesystem": "", } + m.skipFS = make(map[string]struct{}) + for _, fs := range m.config.ExcludeFilesystem { + m.skipFS[fs] = struct{}{} + } // GPFS / IBM Spectrum Scale file system statistics can only be queried by user root user, err := user.Current() @@ -108,154 +114,163 @@ func (m *GpfsCollector) Read(interval time.Duration, output chan lp.CCMetric) { scanner := bufio.NewScanner(cmdStdout) for scanner.Scan() { lineSplit := strings.Fields(scanner.Text()) - if lineSplit[0] == "_fs_io_s_" { - key_value := make(map[string]string) - for i := 1; i < len(lineSplit); i += 2 { - key_value[lineSplit[i]] = lineSplit[i+1] - } - // Ignore keys: - // _n_: node IP address, - // _nn_: node name, - // _cl_: cluster name, - // _d_: number of disks + // Only process lines starting with _fs_io_s_ + if lineSplit[0] != "_fs_io_s_" { + continue + } - filesystem, ok := key_value["_fs_"] - if !ok { - cclog.ComponentError( - m.name, - "Read(): Failed to get filesystem name.") - continue - } + key_value := make(map[string]string) + for i := 1; i < len(lineSplit); i += 2 { + key_value[lineSplit[i]] = lineSplit[i+1] + } - m.tags["filesystem"] = filesystem + // Ignore keys: + // _n_: node IP address, + // _nn_: node name, + // _cl_: cluster name, + // _d_: number of disks - // return code - rc, err := strconv.Atoi(key_value["_rc_"]) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert return code '%s' to int: %v", key_value["_rc_"], err)) - continue - } - if rc != 0 { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Filesystem '%s' is not ok.", filesystem)) - continue - } + filesystem, ok := key_value["_fs_"] + if !ok { + cclog.ComponentError( + m.name, + "Read(): Failed to get filesystem name.") + continue + } - sec, err := strconv.ParseInt(key_value["_t_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert seconds '%s' to int64: %v", key_value["_t_"], err)) - continue - } - msec, err := strconv.ParseInt(key_value["_tu_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert micro seconds '%s' to int64: %v", key_value["_tu_"], err)) - continue - } - timestamp := time.Unix(sec, msec*1000) + // Skip excluded filesystems + if _, skip := m.skipFS[filesystem]; skip { + continue + } - // bytes read - bytesRead, err := strconv.ParseInt(key_value["_br_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert bytes read '%s' to int64: %v", key_value["_br_"], err)) - continue - } - if y, err := lp.New("gpfs_bytes_read", m.tags, m.meta, map[string]interface{}{"value": bytesRead}, timestamp); err == nil { - output <- y - } + m.tags["filesystem"] = filesystem - // bytes written - bytesWritten, err := strconv.ParseInt(key_value["_bw_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert bytes written '%s' to int64: %v", key_value["_bw_"], err)) - continue - } - if y, err := lp.New("gpfs_bytes_written", m.tags, m.meta, map[string]interface{}{"value": bytesWritten}, timestamp); err == nil { - output <- y - } + // return code + rc, err := strconv.Atoi(key_value["_rc_"]) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert return code '%s' to int: %v", key_value["_rc_"], err)) + continue + } + if rc != 0 { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Filesystem '%s' is not ok.", filesystem)) + continue + } - // number of opens - numOpens, err := strconv.ParseInt(key_value["_oc_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert number of opens '%s' to int64: %v", key_value["_oc_"], err)) - continue - } - if y, err := lp.New("gpfs_num_opens", m.tags, m.meta, map[string]interface{}{"value": numOpens}, timestamp); err == nil { - output <- y - } + sec, err := strconv.ParseInt(key_value["_t_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert seconds '%s' to int64: %v", key_value["_t_"], err)) + continue + } + msec, err := strconv.ParseInt(key_value["_tu_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert micro seconds '%s' to int64: %v", key_value["_tu_"], err)) + continue + } + timestamp := time.Unix(sec, msec*1000) - // number of closes - numCloses, err := strconv.ParseInt(key_value["_cc_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert number of closes: '%s' to int64: %v", key_value["_cc_"], err)) - continue - } - if y, err := lp.New("gpfs_num_closes", m.tags, m.meta, map[string]interface{}{"value": numCloses}, timestamp); err == nil { - output <- y - } + // bytes read + bytesRead, err := strconv.ParseInt(key_value["_br_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert bytes read '%s' to int64: %v", key_value["_br_"], err)) + continue + } + if y, err := lp.New("gpfs_bytes_read", m.tags, m.meta, map[string]interface{}{"value": bytesRead}, timestamp); err == nil { + output <- y + } - // number of reads - numReads, err := strconv.ParseInt(key_value["_rdc_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert number of reads: '%s' to int64: %v", key_value["_rdc_"], err)) - continue - } - if y, err := lp.New("gpfs_num_reads", m.tags, m.meta, map[string]interface{}{"value": numReads}, timestamp); err == nil { - output <- y - } + // bytes written + bytesWritten, err := strconv.ParseInt(key_value["_bw_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert bytes written '%s' to int64: %v", key_value["_bw_"], err)) + continue + } + if y, err := lp.New("gpfs_bytes_written", m.tags, m.meta, map[string]interface{}{"value": bytesWritten}, timestamp); err == nil { + output <- y + } - // number of writes - numWrites, err := strconv.ParseInt(key_value["_wc_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert number of writes: '%s' to int64: %v", key_value["_wc_"], err)) - continue - } - if y, err := lp.New("gpfs_num_writes", m.tags, m.meta, map[string]interface{}{"value": numWrites}, timestamp); err == nil { - output <- y - } + // number of opens + numOpens, err := strconv.ParseInt(key_value["_oc_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert number of opens '%s' to int64: %v", key_value["_oc_"], err)) + continue + } + if y, err := lp.New("gpfs_num_opens", m.tags, m.meta, map[string]interface{}{"value": numOpens}, timestamp); err == nil { + output <- y + } - // number of read directories - numReaddirs, err := strconv.ParseInt(key_value["_dir_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert number of read directories: '%s' to int64: %v", key_value["_dir_"], err)) - continue - } - if y, err := lp.New("gpfs_num_readdirs", m.tags, m.meta, map[string]interface{}{"value": numReaddirs}, timestamp); err == nil { - output <- y - } + // number of closes + numCloses, err := strconv.ParseInt(key_value["_cc_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert number of closes: '%s' to int64: %v", key_value["_cc_"], err)) + continue + } + if y, err := lp.New("gpfs_num_closes", m.tags, m.meta, map[string]interface{}{"value": numCloses}, timestamp); err == nil { + output <- y + } - // Number of inode updates - numInodeUpdates, err := strconv.ParseInt(key_value["_iu_"], 10, 64) - if err != nil { - cclog.ComponentError( - m.name, - fmt.Sprintf("Read(): Failed to convert number of inode updates: '%s' to int: %v", key_value["_iu_"], err)) - continue - } - if y, err := lp.New("gpfs_num_inode_updates", m.tags, m.meta, map[string]interface{}{"value": numInodeUpdates}, timestamp); err == nil { - output <- y - } + // number of reads + numReads, err := strconv.ParseInt(key_value["_rdc_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert number of reads: '%s' to int64: %v", key_value["_rdc_"], err)) + continue + } + if y, err := lp.New("gpfs_num_reads", m.tags, m.meta, map[string]interface{}{"value": numReads}, timestamp); err == nil { + output <- y + } + + // number of writes + numWrites, err := strconv.ParseInt(key_value["_wc_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert number of writes: '%s' to int64: %v", key_value["_wc_"], err)) + continue + } + if y, err := lp.New("gpfs_num_writes", m.tags, m.meta, map[string]interface{}{"value": numWrites}, timestamp); err == nil { + output <- y + } + + // number of read directories + numReaddirs, err := strconv.ParseInt(key_value["_dir_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert number of read directories: '%s' to int64: %v", key_value["_dir_"], err)) + continue + } + if y, err := lp.New("gpfs_num_readdirs", m.tags, m.meta, map[string]interface{}{"value": numReaddirs}, timestamp); err == nil { + output <- y + } + + // Number of inode updates + numInodeUpdates, err := strconv.ParseInt(key_value["_iu_"], 10, 64) + if err != nil { + cclog.ComponentError( + m.name, + fmt.Sprintf("Read(): Failed to convert number of inode updates: '%s' to int: %v", key_value["_iu_"], err)) + continue + } + if y, err := lp.New("gpfs_num_inode_updates", m.tags, m.meta, map[string]interface{}{"value": numInodeUpdates}, timestamp); err == nil { + output <- y } } }