/
memory_windows.go
139 lines (120 loc) · 4.45 KB
/
memory_windows.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
// Unless explicitly stated otherwise all files in this repository are licensed
// under the Apache License Version 2.0.
// This product includes software developed at Datadog (https://www.datadoghq.com/).
// Copyright 2016-2019 Datadog, Inc.
// +build windows
package system
import (
"fmt"
"runtime"
"github.com/DataDog/datadog-agent/pkg/autodiscovery/integration"
core "github.com/DataDog/datadog-agent/pkg/collector/corechecks"
"github.com/DataDog/datadog-agent/pkg/util/log"
"github.com/DataDog/datadog-agent/pkg/util/winutil"
"github.com/DataDog/datadog-agent/pkg/util/winutil/pdhutil"
"github.com/DataDog/datadog-agent/pkg/aggregator"
)
// For testing purpose
var virtualMemory = winutil.VirtualMemory
var swapMemory = winutil.SwapMemory
var pageMemory = winutil.PagefileMemory
var runtimeOS = runtime.GOOS
// MemoryCheck doesn't need additional fields
type MemoryCheck struct {
core.CheckBase
cacheBytes *pdhutil.PdhSingleInstanceCounterSet
committedBytes *pdhutil.PdhSingleInstanceCounterSet
pagedBytes *pdhutil.PdhSingleInstanceCounterSet
nonpagedBytes *pdhutil.PdhSingleInstanceCounterSet
}
const mbSize float64 = 1024 * 1024
// Configure handles initial configuration/initialization of the check
func (c *MemoryCheck) Configure(data integration.Data, initConfig integration.Data, source string) (err error) {
if err := c.CommonConfigure(data, source); err != nil {
return err
}
c.cacheBytes, err = pdhutil.GetSingleInstanceCounter("Memory", "Cache Bytes")
if err == nil {
c.committedBytes, err = pdhutil.GetSingleInstanceCounter("Memory", "Committed Bytes")
if err == nil {
c.pagedBytes, err = pdhutil.GetSingleInstanceCounter("Memory", "Pool Paged Bytes")
if err == nil {
c.nonpagedBytes, err = pdhutil.GetSingleInstanceCounter("Memory", "Pool Nonpaged Bytes")
}
}
}
return err
}
// Run executes the check
func (c *MemoryCheck) Run() error {
sender, err := aggregator.GetSender(c.ID())
if err != nil {
return err
}
var val float64
if c.cacheBytes != nil {
val, err = c.cacheBytes.GetValue()
if err == nil {
sender.Gauge("system.mem.cached", float64(val)/mbSize, "", nil)
} else {
log.Warnf("Could not retrieve value for system.mem.cached %v", err)
}
}
if c.committedBytes != nil {
val, err = c.committedBytes.GetValue()
if err == nil {
sender.Gauge("system.mem.committed", float64(val)/mbSize, "", nil)
} else {
log.Warnf("Could not retrieve value for system.mem.committed %v", err)
}
}
if c.pagedBytes != nil {
val, err = c.pagedBytes.GetValue()
if err == nil {
sender.Gauge("system.mem.paged", float64(val)/mbSize, "", nil)
} else {
log.Warnf("Could not retrieve value for system.mem.paged %v", err)
}
}
if c.nonpagedBytes != nil {
val, err = c.nonpagedBytes.GetValue()
if err == nil {
sender.Gauge("system.mem.nonpaged", float64(val)/mbSize, "", nil)
} else {
log.Warnf("Could not retrieve value for system.mem.nonpaged %v", err)
}
}
v, errVirt := virtualMemory()
if errVirt == nil {
sender.Gauge("system.mem.total", float64(v.Total)/mbSize, "", nil)
sender.Gauge("system.mem.free", float64(v.Available)/mbSize, "", nil)
sender.Gauge("system.mem.usable", float64(v.Available)/mbSize, "", nil)
sender.Gauge("system.mem.used", float64(v.Total-v.Available)/mbSize, "", nil)
sender.Gauge("system.mem.pct_usable", float64(100-v.UsedPercent)/100, "", nil)
} else {
log.Errorf("system.MemoryCheck: could not retrieve virtual memory stats: %s", errVirt)
}
s, errSwap := swapMemory()
if errSwap == nil {
sender.Gauge("system.swap.total", float64(s.Total)/mbSize, "", nil)
sender.Gauge("system.swap.free", float64(s.Free)/mbSize, "", nil)
sender.Gauge("system.swap.used", float64(s.Used)/mbSize, "", nil)
sender.Gauge("system.swap.pct_free", float64(100-s.UsedPercent)/100, "", nil)
} else {
log.Errorf("system.MemoryCheck: could not retrieve swap memory stats: %s", errSwap)
}
p, errPage := pageMemory()
if errPage == nil {
sender.Gauge("system.mem.pagefile.pct_free", float64(100-p.UsedPercent)/100, "", nil)
sender.Gauge("system.mem.pagefile.total", float64(p.Total)/mbSize, "", nil)
sender.Gauge("system.mem.pagefile.free", float64(p.Available)/mbSize, "", nil)
sender.Gauge("system.mem.pagefile.used", float64(p.Used)/mbSize, "", nil)
} else {
log.Errorf("system.MemoryCheck: could not retrieve swap memory stats: %s", errSwap)
}
if errVirt != nil && errSwap != nil {
return fmt.Errorf("failed to gather any memory information")
}
sender.Commit()
return nil
}