| 1 | //go:build cgo |
| 2 | |
| 3 | package as400 |
| 4 | |
| 5 | // SPDX-License-Identifier: GPL-3.0-or-later |
| 6 | |
| 7 | import ( |
| 8 | "context" |
| 9 | |
| 10 | "github.com/netdata/netdata/go/plugins/pkg/confopt" |
| 11 | ) |
| 12 | |
| 13 | type collectionGroup interface { |
| 14 | Name() string |
| 15 | Enabled() bool |
| 16 | Collect(ctx context.Context) error |
| 17 | } |
| 18 | |
| 19 | type systemGroup struct { |
| 20 | c *Collector |
| 21 | } |
| 22 | |
| 23 | func (g *systemGroup) Name() string { return "system" } |
| 24 | func (g *systemGroup) Enabled() bool { return true } |
| 25 | |
| 26 | func (g *systemGroup) Collect(ctx context.Context) error { |
| 27 | c := g.c |
| 28 | |
| 29 | if err := c.collectSystemStatus(ctx); err != nil { |
| 30 | if isSQLTemporaryError(err) { |
| 31 | c.Debugf("system status collection failed with temporary error, will show gaps: %v", err) |
| 32 | } else { |
| 33 | c.logErrorOnce("system_status_error", "failed to collect system status: %s", trimDriverMessage(err)) |
| 34 | } |
| 35 | } else { |
| 36 | c.clearErrorOnce("system_status_error") |
| 37 | } |
| 38 | |
| 39 | if err := c.collectMemoryPools(ctx); err != nil { |
| 40 | if isSQLTemporaryError(err) { |
| 41 | c.Debugf("memory pools collection failed with temporary error, will show gaps: %v", err) |
| 42 | } else { |
| 43 | c.logErrorOnce("memory_pools_error", "failed to collect memory pools: %s", trimDriverMessage(err)) |
| 44 | } |
| 45 | } else { |
| 46 | c.clearErrorOnce("memory_pools_error") |
| 47 | } |
| 48 | |
| 49 | if err := c.collectDiskStatus(ctx); err != nil { |
| 50 | if isSQLFeatureError(err) { |
| 51 | c.logOnce("disk_status_unavailable", "disk status monitoring not available on this IBM i version: %v", err) |
| 52 | } else if isSQLTemporaryError(err) { |
| 53 | c.Debugf("disk status collection failed with temporary error, will show gaps: %v", err) |
| 54 | } else { |
| 55 | c.logErrorOnce("disk_status_error", "failed to collect disk status: %s", trimDriverMessage(err)) |
| 56 | } |
| 57 | } else { |
| 58 | c.clearErrorOnce("disk_status_error") |
| 59 | } |
| 60 | |
| 61 | if err := c.collectJobInfo(ctx); err != nil { |
| 62 | if isSQLFeatureError(err) { |
| 63 | c.logOnce("job_info_unavailable", "job info monitoring not available on this IBM i version: %v", err) |
| 64 | } else if isSQLTemporaryError(err) { |
| 65 | c.Debugf("job info collection failed with temporary error, will show gaps: %v", err) |
| 66 | } else { |
| 67 | c.logErrorOnce("job_info_error", "failed to collect job info: %s", trimDriverMessage(err)) |
| 68 | } |
| 69 | } else { |
| 70 | c.clearErrorOnce("job_info_error") |
| 71 | } |
| 72 | |
| 73 | if err := c.collectNetworkConnections(ctx); err != nil { |
| 74 | if isSQLFeatureError(err) { |
| 75 | c.logOnce("network_connections_unavailable", "network connections monitoring not available on this IBM i version: %v", err) |
| 76 | } else if isSQLTemporaryError(err) { |
| 77 | c.Debugf("network connections collection failed with temporary error, will show gaps: %v", err) |
| 78 | } else { |
| 79 | c.logErrorOnce("network_connections_error", "failed to collect network connections: %s", trimDriverMessage(err)) |
| 80 | } |
| 81 | } else { |
| 82 | c.clearErrorOnce("network_connections_error") |
| 83 | } |
| 84 | |
| 85 | if err := c.collectTempStorage(ctx); err != nil { |
| 86 | if isSQLFeatureError(err) { |
| 87 | c.logOnce("temp_storage_unavailable", "temporary storage monitoring not available on this IBM i version: %v", err) |
| 88 | } else if isSQLTemporaryError(err) { |
| 89 | c.Debugf("temporary storage collection failed with temporary error, will show gaps: %v", err) |
| 90 | } else { |
| 91 | c.logErrorOnce("temp_storage_error", "failed to collect temporary storage: %s", trimDriverMessage(err)) |
| 92 | } |
| 93 | } else { |
| 94 | c.clearErrorOnce("temp_storage_error") |
| 95 | } |
| 96 | |
| 97 | return nil |
| 98 | } |
| 99 | |
| 100 | type subsystemGroup struct { |
| 101 | c *Collector |
| 102 | } |
| 103 | |
| 104 | func (g *subsystemGroup) Name() string { return "subsystems" } |
| 105 | func (g *subsystemGroup) Enabled() bool { |
| 106 | return g.c.CollectSubsystemMetrics.IsEnabled() |
| 107 | } |
| 108 | |
| 109 | func (g *subsystemGroup) Collect(ctx context.Context) error { |
| 110 | if !g.Enabled() { |
| 111 | return nil |
| 112 | } |
| 113 | if err := g.c.collectSubsystems(ctx); err != nil { |
| 114 | if isSQLFeatureError(err) { |
| 115 | g.c.Warningf("subsystem monitoring not available on this IBM i version: %v", err) |
| 116 | return nil |
| 117 | } |
| 118 | g.c.logErrorOnce("subsystems_error", "failed to collect subsystems: %s", trimDriverMessage(err)) |
| 119 | return nil |
| 120 | } |
| 121 | g.c.clearErrorOnce("subsystems_error") |
| 122 | return nil |
| 123 | } |
| 124 | |
| 125 | type jobQueueGroup struct { |
| 126 | c *Collector |
| 127 | } |
| 128 | |
| 129 | func (g *jobQueueGroup) Name() string { return "job_queues" } |
| 130 | func (g *jobQueueGroup) Enabled() bool { |
| 131 | return len(g.c.jobQueueTargets) > 0 |
| 132 | } |
| 133 | |
| 134 | func (g *jobQueueGroup) Collect(ctx context.Context) error { |
| 135 | if !g.Enabled() { |
| 136 | return nil |
| 137 | } |
| 138 | if err := g.c.collectJobQueues(ctx); err != nil { |
| 139 | if isSQLFeatureError(err) { |
| 140 | g.c.Warningf("job queue monitoring not available on this IBM i version: %v", err) |
| 141 | return nil |
| 142 | } |
| 143 | g.c.logErrorOnce("job_queues_error", "failed to collect job queues: %s", trimDriverMessage(err)) |
| 144 | return nil |
| 145 | } |
| 146 | g.c.clearErrorOnce("job_queues_error") |
| 147 | return nil |
| 148 | } |
| 149 | |
| 150 | type messageQueueGroup struct { |
| 151 | c *Collector |
| 152 | } |
| 153 | |
| 154 | func (g *messageQueueGroup) Name() string { return "message_queues" } |
| 155 | func (g *messageQueueGroup) Enabled() bool { |
| 156 | return len(g.c.messageQueueTargets) > 0 |
| 157 | } |
| 158 | |
| 159 | func (g *messageQueueGroup) Collect(ctx context.Context) error { |
| 160 | if !g.Enabled() { |
| 161 | return nil |
| 162 | } |
| 163 | if err := g.c.collectMessageQueues(ctx); err != nil { |
| 164 | if isSQLFeatureError(err) { |
| 165 | g.c.Warningf("message queue metrics not available on this IBM i version: %v", err) |
| 166 | return nil |
| 167 | } |
| 168 | if isSQLTemporaryError(err) { |
| 169 | g.c.Debugf("message queue collection failed with temporary error, will show gaps: %v", err) |
| 170 | return nil |
| 171 | } |
| 172 | g.c.logErrorOnce("message_queues_error", "failed to collect message queues: %s", trimDriverMessage(err)) |
| 173 | return nil |
| 174 | } |
| 175 | g.c.clearErrorOnce("message_queues_error") |
| 176 | return nil |
| 177 | } |
| 178 | |
| 179 | type outputQueueGroup struct { |
| 180 | c *Collector |
| 181 | } |
| 182 | |
| 183 | func (g *outputQueueGroup) Name() string { return "output_queues" } |
| 184 | func (g *outputQueueGroup) Enabled() bool { |
| 185 | return len(g.c.outputQueueTargets) > 0 |
| 186 | } |
| 187 | |
| 188 | func (g *outputQueueGroup) Collect(ctx context.Context) error { |
| 189 | if !g.Enabled() { |
| 190 | return nil |
| 191 | } |
| 192 | if err := g.c.collectOutputQueues(ctx); err != nil { |
| 193 | if isSQLFeatureError(err) { |
| 194 | g.c.Warningf("output queue metrics not available on this IBM i version: %v", err) |
| 195 | return nil |
| 196 | } |
| 197 | if isSQLTemporaryError(err) { |
| 198 | g.c.Debugf("output queue collection failed with temporary error, will show gaps: %v", err) |
| 199 | return nil |
| 200 | } |
| 201 | g.c.logErrorOnce("output_queues_error", "failed to collect output queues: %s", trimDriverMessage(err)) |
| 202 | return nil |
| 203 | } |
| 204 | g.c.clearErrorOnce("output_queues_error") |
| 205 | return nil |
| 206 | } |
| 207 | |
| 208 | type diskGroup struct { |
| 209 | c *Collector |
| 210 | } |
| 211 | |
| 212 | func (g *diskGroup) Name() string { return "disks" } |
| 213 | func (g *diskGroup) Enabled() bool { |
| 214 | return g.c.CollectDiskMetrics.IsEnabled() |
| 215 | } |
| 216 | |
| 217 | func (g *diskGroup) Collect(ctx context.Context) error { |
| 218 | if !g.Enabled() { |
| 219 | return nil |
| 220 | } |
| 221 | if err := g.c.collectDiskInstancesEnhanced(ctx); err != nil { |
| 222 | if isSQLFeatureError(err) { |
| 223 | g.c.logOnce("disk_enhanced_unavailable", "enhanced disk metrics not available, using basic collection: %v", err) |
| 224 | if basicErr := g.c.collectDiskInstances(ctx); basicErr != nil { |
| 225 | g.c.logErrorOnce("disk_instances_error", "failed to collect disk instances: %s", trimDriverMessage(basicErr)) |
| 226 | } |
| 227 | } else if isSQLTemporaryError(err) { |
| 228 | g.c.Debugf("disk instances collection failed with temporary error, will show gaps: %v", err) |
| 229 | } else { |
| 230 | g.c.logErrorOnce("disk_instances_enhanced_error", "failed to collect enhanced disk instances: %s", trimDriverMessage(err)) |
| 231 | } |
| 232 | } else { |
| 233 | g.c.clearErrorOnce("disk_instances_enhanced_error") |
| 234 | g.c.clearErrorOnce("disk_instances_error") |
| 235 | } |
| 236 | return nil |
| 237 | } |
| 238 | |
| 239 | type activeJobGroup struct { |
| 240 | c *Collector |
| 241 | } |
| 242 | |
| 243 | func (g *activeJobGroup) Name() string { return "active_jobs" } |
| 244 | func (g *activeJobGroup) Enabled() bool { |
| 245 | return g.c.CollectActiveJobs.IsEnabled() && len(g.c.activeJobTargets) > 0 |
| 246 | } |
| 247 | |
| 248 | func (g *activeJobGroup) Collect(ctx context.Context) error { |
| 249 | if !g.Enabled() { |
| 250 | return nil |
| 251 | } |
| 252 | if err := g.c.collectActiveJobs(ctx); err != nil { |
| 253 | if isSQLFeatureError(err) { |
| 254 | g.c.Warningf("active job metrics not available on this IBM i version: %v", err) |
| 255 | g.c.CollectActiveJobs = confopt.AutoBoolDisabled |
| 256 | return nil |
| 257 | } |
| 258 | if isSQLTemporaryError(err) { |
| 259 | g.c.Debugf("active job collection failed with temporary error, will show gaps: %v", err) |
| 260 | return nil |
| 261 | } |
| 262 | g.c.logErrorOnce("active_jobs_error", "failed to collect active jobs: %s", trimDriverMessage(err)) |
| 263 | return nil |
| 264 | } |
| 265 | g.c.clearErrorOnce("active_jobs_error") |
| 266 | return nil |
| 267 | } |
| 268 | |
| 269 | type networkInterfaceGroup struct { |
| 270 | c *Collector |
| 271 | } |
| 272 | |
| 273 | func (g *networkInterfaceGroup) Name() string { return "network_interfaces" } |
| 274 | func (g *networkInterfaceGroup) Enabled() bool { return true } |
| 275 | |
| 276 | func (g *networkInterfaceGroup) Collect(ctx context.Context) error { |
| 277 | if err := g.c.collectNetworkInterfaces(ctx); err != nil { |
| 278 | if isSQLFeatureError(err) { |
| 279 | g.c.Warningf("network interface monitoring not available on this IBM i version: %v", err) |
| 280 | return nil |
| 281 | } |
| 282 | if isSQLTemporaryError(err) { |
| 283 | g.c.Debugf("network interface collection failed with temporary error, will show gaps: %v", err) |
| 284 | return nil |
| 285 | } |
| 286 | g.c.logErrorOnce("network_interfaces_error", "failed to collect network interfaces: %s", trimDriverMessage(err)) |
| 287 | return nil |
| 288 | } |
| 289 | g.c.clearErrorOnce("network_interfaces_error") |
| 290 | return nil |
| 291 | } |
| 292 | |
| 293 | type systemActivityGroup struct { |
| 294 | c *Collector |
| 295 | } |
| 296 | |
| 297 | func (g *systemActivityGroup) Name() string { return "system_activity" } |
| 298 | func (g *systemActivityGroup) Enabled() bool { return true } |
| 299 | |
| 300 | func (g *systemActivityGroup) Collect(ctx context.Context) error { |
| 301 | if err := g.c.collectSystemActivity(ctx); err != nil { |
| 302 | if isSQLFeatureError(err) { |
| 303 | g.c.logOnce("system_activity_unavailable", "system activity monitoring not available on this IBM i version: %v", err) |
| 304 | return nil |
| 305 | } |
| 306 | if isSQLTemporaryError(err) { |
| 307 | g.c.Debugf("system activity collection failed with temporary error, will show gaps: %v", err) |
| 308 | return nil |
| 309 | } |
| 310 | g.c.logErrorOnce("system_activity_error", "failed to collect system activity: %s", trimDriverMessage(err)) |
| 311 | return nil |
| 312 | } |
| 313 | g.c.clearErrorOnce("system_activity_error") |
| 314 | return nil |
| 315 | } |
| 316 | |
| 317 | type httpServerGroup struct { |
| 318 | c *Collector |
| 319 | } |
| 320 | |
| 321 | func (g *httpServerGroup) Name() string { return "http_server" } |
| 322 | func (g *httpServerGroup) Enabled() bool { |
| 323 | return g.c.CollectHTTPServerMetrics.IsEnabled() |
| 324 | } |
| 325 | |
| 326 | func (g *httpServerGroup) Collect(ctx context.Context) error { |
| 327 | if !g.Enabled() { |
| 328 | return nil |
| 329 | } |
| 330 | if err := g.c.collectHTTPServerInfo(ctx); err != nil { |
| 331 | if isSQLFeatureError(err) { |
| 332 | g.c.Warningf("HTTP server metrics not available on this IBM i version: %v", err) |
| 333 | g.c.CollectHTTPServerMetrics = confopt.AutoBoolDisabled |
| 334 | return nil |
| 335 | } |
| 336 | if isSQLTemporaryError(err) { |
| 337 | g.c.Debugf("HTTP server metrics collection failed with temporary error, will show gaps: %v", err) |
| 338 | return nil |
| 339 | } |
| 340 | g.c.logErrorOnce("http_server_error", "failed to collect HTTP server metrics: %s", trimDriverMessage(err)) |
| 341 | return nil |
| 342 | } |
| 343 | g.c.clearErrorOnce("http_server_error") |
| 344 | return nil |
| 345 | } |
| 346 | |
| 347 | type planCacheGroup struct { |
| 348 | c *Collector |
| 349 | } |
| 350 | |
| 351 | func (g *planCacheGroup) Name() string { return "plan_cache" } |
| 352 | func (g *planCacheGroup) Enabled() bool { |
| 353 | return g.c.CollectPlanCacheMetrics.IsEnabled() |
| 354 | } |
| 355 | |
| 356 | func (g *planCacheGroup) Collect(ctx context.Context) error { |
| 357 | if !g.Enabled() { |
| 358 | return nil |
| 359 | } |
| 360 | if err := g.c.collectPlanCache(ctx); err != nil { |
| 361 | if isSQLFeatureError(err) { |
| 362 | tmsg := trimDriverMessage(err) |
| 363 | g.c.logErrorOnce("plan_cache_missing_privs", "plan cache analysis not available or requires additional authority: %s", tmsg) |
| 364 | g.c.CollectPlanCacheMetrics = confopt.AutoBoolDisabled |
| 365 | return nil |
| 366 | } |
| 367 | if isSQLTemporaryError(err) { |
| 368 | g.c.Debugf("plan cache metrics collection failed with temporary error, will show gaps: %v", err) |
| 369 | return nil |
| 370 | } |
| 371 | g.c.logErrorOnce("plan_cache_error", "failed to collect plan cache metrics: %s", trimDriverMessage(err)) |
| 372 | return nil |
| 373 | } |
| 374 | g.c.clearErrorOnce("plan_cache_missing_privs") |
| 375 | g.c.clearErrorOnce("plan_cache_error") |
| 376 | return nil |
| 377 | } |