Skip to content

Commit 4bb70ab

Browse files
leopoldjuergenGitHub Enterprise
leopoldjuergen
authored and
GitHub Enterprise
committed
Merge pull request #30 from ZaaS/mingxia/enhance_logging
Enhance err logging and response examples
2 parents 7bf93e8 + 4b84df7 commit 4bb70ab

11 files changed

+572
-61
lines changed

‎.gitignore‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1 +1,2 @@
11
/spectrum-virtualize-exporter
2+
/temp.yaml

‎CHANGELOG.md‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
1-
## 0.7.0 / 2019-06-28
21

2+
* [Enhance] Enhance err logging and response examples
3+
4+
## 0.7.0 / 2019-06-28
35
* [FEATURE] Add 'target' label, its value is ipaddress
46

57
## 0.6.0 / 2019-06-21

‎collector/collector.go‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -134,21 +134,21 @@ func (c *SVCCollector) collectForHost(host utils.Targets, ch chan<- prometheus.M
134134
// get our authtoken for future interactions
135135
authtoken, err := spectrumClient.RetriveAuthToken()
136136
if err != nil {
137-
log.Debugf("Error getting auth token for %s", host.IpAddress)
138-
requestErrorCount += 1
137+
log.Errorf("Error getting auth token for %s, the error was %v.", host.IpAddress, err)
138+
requestErrorCount++
139139
success = 0
140140
return
141141

142142
}
143143
authTokenCache.Store(host.IpAddress, authtoken)
144144
result, _ := authTokenCache.Load(host.IpAddress)
145145
spectrumClient.AuthToken = result.(string)
146-
authTokenMiss += 1
146+
authTokenMiss++
147147
success = 1
148148
} else {
149149
log.Debugf("Authtoken pulled from cache for %s", host.IpAddress)
150150
spectrumClient.AuthToken = result.(string)
151-
authTokenHit += 1
151+
authTokenHit++
152152
success = 1
153153
}
154154
//test to make sure that our auth token is good
@@ -157,8 +157,8 @@ func (c *SVCCollector) collectForHost(host utils.Targets, ch chan<- prometheus.M
157157
systemMetrics, err := spectrumClient.CallSpectrumAPI(validateURL)
158158
if err != nil {
159159
authTokenCache.Delete(host.IpAddress)
160-
log.Debugf("Invalidating authToken for %s, re-requesting authtoken....", host.IpAddress)
161-
lc += 1
160+
log.Infof("\nInvalidating authToken for %s, re-requesting authtoken....", host.IpAddress)
161+
lc++
162162
} else {
163163
spectrumClient.Hostname = gjson.Get(systemMetrics, "name").String()
164164
//We have a valid auth token, we can break out of this loop
@@ -167,8 +167,8 @@ func (c *SVCCollector) collectForHost(host utils.Targets, ch chan<- prometheus.M
167167
}
168168
if lc > 3 {
169169
// looped and failed multiple times, so need to go further
170-
log.Debugf("Error getting auth token for %s", host.IpAddress)
171-
requestErrorCount += 1
170+
log.Errorf("Error getting auth token for %s, please check network or username and password", host.IpAddress)
171+
requestErrorCount++
172172
success = 0
173173
return
174174
}

‎collector/mdisk_collector.go‎

Lines changed: 34 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -34,18 +34,46 @@ func (*mdiskCollector) Describe(ch chan<- *prometheus.Desc) {
3434
//Collect collects metrics from Spectrum Virtualize Restful API
3535
func (c *mdiskCollector) Collect(sClient utils.SpectrumClient, ch chan<- prometheus.Metric) error {
3636

37-
log.Debugln("MDisk collector is starting")
37+
log.Debugln("Entering MDisk collector ...")
3838
reqSystemURL := "https://" + sClient.IpAddress + ":7443/rest/lsmdisk"
39-
mDiskRes, err := sClient.CallSpectrumAPI(reqSystemURL)
40-
mDiskArray := gjson.Parse(mDiskRes).Array()
41-
for _, mdisk := range mDiskArray {
39+
mDiskResp, err := sClient.CallSpectrumAPI(reqSystemURL)
40+
if err != nil {
41+
log.Errorf("Executing lsmdisk cmd failed: %s", err)
42+
}
43+
log.Debugln("Response of lsmdisk: ", mDiskResp)
44+
//This is a sample output of lsmdisk
45+
// [
46+
// {
47+
// "id": "0",
48+
// "name": "mdisk0",
49+
// "status": "online",
50+
// "mode": "array",
51+
// "mdisk_grp_id": "0",
52+
// "mdisk_grp_name": "Pool0",
53+
// "capacity": "99.1TB",
54+
// "ctrl_LUN_#": "",
55+
// "controller_name": "",
56+
// "UID": "",
57+
// "tier": "tier0_flash",
58+
// "encrypt": "no",
59+
// "site_id": "",
60+
// "site_name": "",
61+
// "distributed": "yes",
62+
// "dedupe": "no",
63+
// "over_provisioned": "yes",
64+
// "supports_unmap": "yes"
65+
// }
66+
// ]
67+
mDisks := gjson.Parse(mDiskResp).Array()
68+
for _, mdisk := range mDisks {
4269
capacity_bytes, err := utils.ToBytes(mdisk.Get("capacity").String())
43-
ch <- prometheus.MustNewConstMetric(mdiskCapacity, prometheus.GaugeValue, float64(capacity_bytes), sClient.IpAddress, sClient.Hostname, mdisk.Get("name").String(), mdisk.Get("status").String(), mdisk.Get("mdisk_grp_name").String(), mdisk.Get("tier").String())
4470
if err != nil {
45-
return err
71+
log.Errorf("Converting capacity unit failed: %s", err)
4672
}
73+
ch <- prometheus.MustNewConstMetric(mdiskCapacity, prometheus.GaugeValue, float64(capacity_bytes), sClient.IpAddress, sClient.Hostname, mdisk.Get("name").String(), mdisk.Get("status").String(), mdisk.Get("mdisk_grp_name").String(), mdisk.Get("tier").String())
4774

4875
}
76+
log.Debugln("Leaving MDisk collector.")
4977
return err
5078

5179
}

‎collector/mdiskgrp_collector.go‎

Lines changed: 95 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -83,63 +83,153 @@ func (*mdiskgrpCollector) Describe(ch chan<- *prometheus.Desc) {
8383
//Collect collects metrics from Spectrum Virtualize Restful API
8484
func (c *mdiskgrpCollector) Collect(sClient utils.SpectrumClient, ch chan<- prometheus.Metric) error {
8585

86-
log.Debugln("MDiskgrp collector is starting")
86+
log.Debugln("Entering MDiskgrp collector ...")
8787
reqSystemURL := "https://" + sClient.IpAddress + ":7443/rest/lsmdiskgrp"
88-
mDiskGrpRes, err := sClient.CallSpectrumAPI(reqSystemURL)
89-
mDiskGrpArray := gjson.Parse(mDiskGrpRes).Array()
88+
mDiskGrpResp, err := sClient.CallSpectrumAPI(reqSystemURL)
89+
if err != nil {
90+
log.Errorf("Executing lsmdiskgrp cmd failed: %s", err)
91+
}
92+
log.Debugln("Response of lsmdiskgrp: ", mDiskGrpResp)
93+
// This is a sample output of lsmdiskgrp
94+
// [
95+
// {
96+
// "id": "0",
97+
// "name": "Pool0",
98+
// "status": "online",
99+
// "mdisk_count": "1",
100+
// "vdisk_count": "5",
101+
// "capacity": "99.01TB",
102+
// "extent_size": "1024",
103+
// "free_capacity": "98.46TB",
104+
// "virtual_capacity": "656.00GB",
105+
// "used_capacity": "556.00GB",
106+
// "real_capacity": "558.02GB",
107+
// "overallocation": "0",
108+
// "warning": "80",
109+
// "easy_tier": "auto",
110+
// "easy_tier_status": "balanced",
111+
// "compression_active": "no",
112+
// "compression_virtual_capacity": "0.00MB",
113+
// "compression_compressed_capacity": "0.00MB",
114+
// "compression_uncompressed_capacity": "0.00MB",
115+
// "parent_mdisk_grp_id": "0",
116+
// "parent_mdisk_grp_name": "Pool0",
117+
// "child_mdisk_grp_count": "0",
118+
// "child_mdisk_grp_capacity": "0.00MB",
119+
// "type": "parent",
120+
// "encrypt": "no",
121+
// "owner_type": "none",
122+
// "site_id": "",
123+
// "site_name": "",
124+
// "data_reduction": "no",
125+
// "used_capacity_before_reduction": "0.00MB",
126+
// "used_capacity_after_reduction": "0.00MB",
127+
// "overhead_capacity": "0.00MB",
128+
// "deduplication_capacity_saving": "0.00MB",
129+
// "reclaimable_capacity": "0.00MB"
130+
// }
131+
// ]
132+
133+
mDiskGrpArray := gjson.Parse(mDiskGrpResp).Array()
90134
for _, mdiskgrp := range mDiskGrpArray {
91135
mdiskgrp_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("capacity").String())
136+
if err != nil {
137+
log.Errorf("Converting capacity unit failed: %s", err)
138+
}
92139
ch <- prometheus.MustNewConstMetric(mdiskgrp_capacity, prometheus.GaugeValue, float64(mdiskgrp_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
93140

94141
extent_size_bytes, err := utils.ToBytes(mdiskgrp.Get("extent_size").String() + "MB")
142+
if err != nil {
143+
log.Errorf("Converting capacity unit failed: %s", err)
144+
}
95145
ch <- prometheus.MustNewConstMetric(extent_size, prometheus.GaugeValue, float64(extent_size_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
96146

97147
free_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("free_capacity").String())
148+
if err != nil {
149+
log.Errorf("Converting capacity unit failed: %s", err)
150+
}
98151
ch <- prometheus.MustNewConstMetric(free_capacity, prometheus.GaugeValue, float64(free_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
99152

100153
virtual_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("virtual_capacity").String())
154+
if err != nil {
155+
log.Errorf("Converting capacity unit failed: %s", err)
156+
}
101157
ch <- prometheus.MustNewConstMetric(virtual_capacity, prometheus.GaugeValue, float64(virtual_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
102158

103159
used_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("used_capacity").String())
160+
if err != nil {
161+
log.Errorf("Converting capacity unit failed: %s", err)
162+
}
104163
ch <- prometheus.MustNewConstMetric(used_capacity, prometheus.GaugeValue, float64(used_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
105164

106165
real_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("real_capacity").String())
166+
if err != nil {
167+
log.Errorf("Converting capacity unit failed: %s", err)
168+
}
107169
ch <- prometheus.MustNewConstMetric(real_capacity, prometheus.GaugeValue, float64(real_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
108170

109171
overallocation_pc, err := strconv.ParseFloat(mdiskgrp.Get("overallocation").String(), 64)
172+
if err != nil {
173+
log.Errorf("Converting capacity unit failed: %s", err)
174+
}
110175
ch <- prometheus.MustNewConstMetric(overallocation, prometheus.GaugeValue, float64(overallocation_pc), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
111176

112177
mdiskgrp_compression_active_value, err := utils.ToBool(mdiskgrp.Get("compression_active").String())
178+
if err != nil {
179+
log.Errorf("Converting capacity unit failed: %s", err)
180+
}
113181
ch <- prometheus.MustNewConstMetric(mdiskgrp_compression_active, prometheus.GaugeValue, mdiskgrp_compression_active_value, sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
114182

115183
mdiskgrp_compression_virtual_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("compression_virtual_capacity").String())
184+
if err != nil {
185+
log.Errorf("Converting capacity unit failed: %s", err)
186+
}
116187
ch <- prometheus.MustNewConstMetric(mdiskgrp_compression_virtual_capacity, prometheus.GaugeValue, float64(mdiskgrp_compression_virtual_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
117188

118189
mdiskgrp_compression_compressed_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("compression_compressed_capacity").String())
190+
if err != nil {
191+
log.Errorf("Converting capacity unit failed: %s", err)
192+
}
119193
ch <- prometheus.MustNewConstMetric(mdiskgrp_compression_compressed_capacity, prometheus.GaugeValue, float64(mdiskgrp_compression_compressed_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
120194

121195
mdiskgrp_compression_uncompressed_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("compression_uncompressed_capacity").String())
196+
if err != nil {
197+
log.Errorf("Converting capacity unit failed: %s", err)
198+
}
122199
ch <- prometheus.MustNewConstMetric(mdiskgrp_compression_uncompressed_capacity, prometheus.GaugeValue, float64(mdiskgrp_compression_uncompressed_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
123200

124201
mdiskgrp_used_capacity_before_reduction_bytes, err := utils.ToBytes(mdiskgrp.Get("used_capacity_before_reduction").String())
202+
if err != nil {
203+
log.Errorf("Converting capacity unit failed: %s", err)
204+
}
125205
ch <- prometheus.MustNewConstMetric(mdiskgrp_used_capacity_before_reduction, prometheus.GaugeValue, float64(mdiskgrp_used_capacity_before_reduction_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
126206

127207
mdiskgrp_used_capacity_after_reduction_bytes, err := utils.ToBytes(mdiskgrp.Get("used_capacity_after_reduction").String())
208+
if err != nil {
209+
log.Errorf("Converting capacity unit failed: %s", err)
210+
}
128211
ch <- prometheus.MustNewConstMetric(mdiskgrp_used_capacity_after_reduction, prometheus.GaugeValue, float64(mdiskgrp_used_capacity_after_reduction_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
129212

130213
mdiskgrp_overhead_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("overhead_capacity").String())
214+
if err != nil {
215+
log.Errorf("Converting capacity unit failed: %s", err)
216+
}
131217
ch <- prometheus.MustNewConstMetric(mdiskgrp_overhead_capacity, prometheus.GaugeValue, float64(mdiskgrp_overhead_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
132218

133219
mdiskgrp_deduplication_capcacity_saving_bytes, err := utils.ToBytes(mdiskgrp.Get("deduplication_capacity_saving").String())
220+
if err != nil {
221+
log.Errorf("Converting capacity unit failed: %s", err)
222+
}
134223
ch <- prometheus.MustNewConstMetric(mdiskgrp_deduplication_capcacity_saving, prometheus.GaugeValue, float64(mdiskgrp_deduplication_capcacity_saving_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
135224

136225
reclaimable_capacity_bytes, err := utils.ToBytes(mdiskgrp.Get("reclaimable_capacity").String())
137-
ch <- prometheus.MustNewConstMetric(reclaimable_capacity, prometheus.GaugeValue, float64(reclaimable_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
138226
if err != nil {
139-
return err
227+
log.Errorf("Converting capacity unit failed: %s", err)
140228
}
229+
ch <- prometheus.MustNewConstMetric(reclaimable_capacity, prometheus.GaugeValue, float64(reclaimable_capacity_bytes), sClient.IpAddress, sClient.Hostname, mdiskgrp.Get("name").String(), mdiskgrp.Get("status").String())
141230

142231
}
232+
log.Debugln("Leaving MDiskgrp collector.")
143233
return err
144234

145235
}

‎collector/node_stats_collector.go‎

Lines changed: 64 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -103,14 +103,75 @@ func (*nodeStatsCollector) Describe(ch chan<- *prometheus.Desc) {
103103
//Collect collects metrics from Spectrum Virtualize Restful API
104104
func (c *nodeStatsCollector) Collect(sClient utils.SpectrumClient, ch chan<- prometheus.Metric) error {
105105

106-
log.Debugln("NodeStats collector is starting")
106+
log.Debugln("Entering NodeStats collector ...")
107107
reqSystemURL := "https://" + sClient.IpAddress + ":7443/rest/lsnodestats"
108-
nodeStats, err := sClient.CallSpectrumAPI(reqSystemURL)
109-
nodeStatsArray := gjson.Parse(nodeStats).Array()
108+
nodeStatsResp, err := sClient.CallSpectrumAPI(reqSystemURL)
109+
if err != nil {
110+
log.Errorf("Executing lsnodestats cmd failed: %s", err)
111+
}
112+
log.Debugln("Response of lsnodestats: ", nodeStatsResp)
113+
// This is a sample output of lsnodestats
114+
// [
115+
// {
116+
// "node_id": "1",
117+
// "node_name": "node1",
118+
// "stat_name": "compression_cpu_pc",
119+
// "stat_current": "0",
120+
// "stat_peak": "0",
121+
// "stat_peak_time": "181217083654"
122+
// },
123+
// {
124+
// "node_id": "1",
125+
// "node_name": "node1",
126+
// "stat_name": "cpu_pc",
127+
// "stat_current": "1",
128+
// "stat_peak": "1",
129+
// "stat_peak_time": "181217083654"
130+
// },
131+
// {
132+
// "node_id": "1",
133+
// "node_name": "node1",
134+
// "stat_name": "fc_mb",
135+
// "stat_current": "0",
136+
// "stat_peak": "0",
137+
// "stat_peak_time": "181217083654"
138+
// },
139+
// ....
140+
// ....
141+
// {
142+
// "node_id": "2",
143+
// "node_name": "node2",
144+
// "stat_name": "mdisk_io",
145+
// "stat_current": "0",
146+
// "stat_peak": "0",
147+
// "stat_peak_time": "181217083656"
148+
// },
149+
// {
150+
// "node_id": "2",
151+
// "node_name": "node2",
152+
// "stat_name": "mdisk_ms",
153+
// "stat_current": "0",
154+
// "stat_peak": "0",
155+
// "stat_peak_time": "181217083656"
156+
// },
157+
// {
158+
// "node_id": "2",
159+
// "node_name": "node2",
160+
// "stat_name": "drive_mb",
161+
// "stat_current": "232",
162+
// "stat_peak": "422",
163+
// "stat_peak_time": "181217083651"
164+
// }
165+
// ....
166+
// ....
167+
// ]
168+
169+
nodeStatsArray := gjson.Parse(nodeStatsResp).Array()
110170
for i, nodeStats_metric := range nodeStats_metrics {
111171
ch <- prometheus.MustNewConstMetric(nodeStats_metric, prometheus.GaugeValue, nodeStatsArray[i].Get("stat_current").Float(), sClient.IpAddress, sClient.Hostname, nodeStatsArray[i].Get("node_name").String())
112172
ch <- prometheus.MustNewConstMetric(nodeStats_metric, prometheus.GaugeValue, nodeStatsArray[len(nodeStatsArray)-len(nodeStats_metrics)+i].Get("stat_current").Float(), sClient.IpAddress, sClient.Hostname, nodeStatsArray[len(nodeStatsArray)-len(nodeStats_metrics)+i].Get("node_name").String())
113173
}
174+
log.Debugln("Leaving NodeStats collector.")
114175
return err
115176

116177
}

0 commit comments

Comments
 (0)