telegraf/plugins/inputs/monit/monit.go

436 lines
12 KiB
Go
Raw Normal View History

2020-01-22 22:45:18 +00:00
package monit
import (
"encoding/xml"
"fmt"
"net/http"
2020-01-22 22:45:18 +00:00
"github.com/influxdata/telegraf"
"github.com/influxdata/telegraf/internal"
"github.com/influxdata/telegraf/internal/tls"
"github.com/influxdata/telegraf/plugins/inputs"
"golang.org/x/net/html/charset"
)
const (
fileSystem string = "0"
directory = "1"
file = "2"
process = "3"
remoteHost = "4"
system = "5"
fifo = "6"
program = "7"
network = "8"
)
var pendingActions = []string{"ignore", "alert", "restart", "stop", "exec", "unmonitor", "start", "monitor"}
type Status struct {
Server Server `xml:"server"`
Platform Platform `xml:"platform"`
Services []Service `xml:"service"`
}
type Server struct {
ID string `xml:"id"`
Version string `xml:"version"`
Uptime int64 `xml:"uptime"`
Poll int `xml:"poll"`
LocalHostname string `xml:"localhostname"`
StartDelay int `xml:"startdelay"`
ControlFile string `xml:"controlfile"`
}
type Platform struct {
Name string `xml:"name"`
Release string `xml:"release"`
Version string `xml:"version"`
Machine string `xml:"machine"`
CPU int `xml:"cpu"`
Memory int `xml:"memory"`
Swap int `xml:"swap"`
}
type Service struct {
Type string `xml:"type,attr"`
Name string `xml:"name"`
Status int `xml:"status"`
MonitoringStatus int `xml:"monitor"`
MonitorMode int `xml:"monitormode"`
PendingAction int `xml:"pendingaction"`
Memory Memory `xml:"memory"`
CPU CPU `xml:"cpu"`
System System `xml:"system"`
Size int64 `xml:"size"`
Mode int `xml:"mode"`
Program Program `xml:"program"`
Block Block `xml:"block"`
Inode Inode `xml:"inode"`
Pid int64 `xml:"pid"`
ParentPid int64 `xml:"ppid"`
Threads int `xml:"threads"`
Children int `xml:"children"`
Port Port `xml:"port"`
Link Link `xml:"link"`
}
type Link struct {
State int `xml:"state"`
Speed int64 `xml:"speed"`
Duplex int `xml:"duplex"`
Download Download `xml:"download"`
Upload Upload `xml:"upload"`
}
type Download struct {
Packets struct {
Now int64 `xml:"now"`
Total int64 `xml:"total"`
} `xml:"packets"`
Bytes struct {
Now int64 `xml:"now"`
Total int64 `xml:"total"`
} `xml:"bytes"`
Errors struct {
Now int64 `xml:"now"`
Total int64 `xml:"total"`
} `xml:"errors"`
}
type Upload struct {
Packets struct {
Now int64 `xml:"now"`
Total int64 `xml:"total"`
} `xml:"packets"`
Bytes struct {
Now int64 `xml:"now"`
Total int64 `xml:"total"`
} `xml:"bytes"`
Errors struct {
Now int64 `xml:"now"`
Total int64 `xml:"total"`
} `xml:"errors"`
}
type Port struct {
Hostname string `xml:"hostname"`
PortNumber int64 `xml:"portnumber"`
Request string `xml:"request"`
Protocol string `xml:"protocol"`
Type string `xml:"type"`
}
type Block struct {
Percent float64 `xml:"percent"`
Usage float64 `xml:"usage"`
Total float64 `xml:"total"`
}
type Inode struct {
Percent float64 `xml:"percent"`
Usage float64 `xml:"usage"`
Total float64 `xml:"total"`
}
type Program struct {
Started int64 `xml:"started"`
Status int `xml:"status"`
}
type Memory struct {
Percent float64 `xml:"percent"`
PercentTotal float64 `xml:"percenttotal"`
Kilobyte int64 `xml:"kilobyte"`
KilobyteTotal int64 `xml:"kilobytetotal"`
}
type CPU struct {
Percent float64 `xml:"percent"`
PercentTotal float64 `xml:"percenttotal"`
}
type System struct {
Load struct {
Avg01 float64 `xml:"avg01"`
Avg05 float64 `xml:"avg05"`
Avg15 float64 `xml:"avg15"`
} `xml:"load"`
CPU struct {
User float64 `xml:"user"`
System float64 `xml:"system"`
Wait float64 `xml:"wait"`
} `xml:"cpu"`
Memory struct {
Percent float64 `xml:"percent"`
Kilobyte int64 `xml:"kilobyte"`
} `xml:"memory"`
Swap struct {
Percent float64 `xml:"percent"`
Kilobyte float64 `xml:"kilobyte"`
} `xml:"swap"`
}
type Monit struct {
Address string `toml:"address"`
Username string `toml:"username"`
Password string `toml:"password"`
client HTTPClient
tls.ClientConfig
Timeout internal.Duration `toml:"timeout"`
}
type HTTPClient interface {
MakeRequest(req *http.Request) (*http.Response, error)
SetHTTPClient(client *http.Client)
HTTPClient() *http.Client
}
type Messagebody struct {
Metrics []string `json:"metrics"`
}
type RealHTTPClient struct {
client *http.Client
}
func (c *RealHTTPClient) MakeRequest(req *http.Request) (*http.Response, error) {
return c.client.Do(req)
}
func (c *RealHTTPClient) SetHTTPClient(client *http.Client) {
c.client = client
}
func (c *RealHTTPClient) HTTPClient() *http.Client {
return c.client
}
func (m *Monit) Description() string {
return "Read metrics and status information about processes managed by Monit"
}
var sampleConfig = `
## Monit HTTPD address
2020-01-22 22:45:18 +00:00
address = "http://127.0.0.1:2812"
## Username and Password for Monit
# username = ""
# password = ""
2020-01-22 22:45:18 +00:00
## Amount of time allowed to complete the HTTP request
# timeout = "5s"
## Optional TLS Config
# tls_ca = "/etc/telegraf/ca.pem"
# tls_cert = "/etc/telegraf/cert.pem"
# tls_key = "/etc/telegraf/key.pem"
## Use TLS but skip chain & host verification
# insecure_skip_verify = false
`
func (m *Monit) SampleConfig() string {
return sampleConfig
}
func (m *Monit) Init() error {
tlsCfg, err := m.ClientConfig.TLSConfig()
if err != nil {
return err
}
client := &http.Client{
Transport: &http.Transport{
TLSClientConfig: tlsCfg,
Proxy: http.ProxyFromEnvironment,
},
Timeout: m.Timeout.Duration,
}
m.client.SetHTTPClient(client)
return nil
}
func (m *Monit) Gather(acc telegraf.Accumulator) error {
req, err := http.NewRequest("GET", fmt.Sprintf("%s/_status?format=xml", m.Address), nil)
if err != nil {
return err
}
if len(m.Username) > 0 || len(m.Password) > 0 {
req.SetBasicAuth(m.Username, m.Password)
}
resp, err := m.client.MakeRequest(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode == 200 {
var status Status
decoder := xml.NewDecoder(resp.Body)
decoder.CharsetReader = charset.NewReaderLabel
if err := decoder.Decode(&status); err != nil {
return fmt.Errorf("error parsing input: %v", err)
}
tags := map[string]string{
"version": status.Server.Version,
"source": status.Server.LocalHostname,
"platform_name": status.Platform.Name,
}
for _, service := range status.Services {
fields := make(map[string]interface{})
tags["status"] = serviceStatus(service)
fields["status_code"] = service.Status
tags["pending_action"] = pendingAction(service)
fields["pending_action_code"] = service.PendingAction
tags["monitoring_status"] = monitoringStatus(service)
fields["monitoring_status_code"] = service.MonitoringStatus
tags["monitoring_mode"] = monitoringMode(service)
fields["monitoring_mode_code"] = service.MonitorMode
tags["service"] = service.Name
if service.Type == fileSystem {
fields["mode"] = service.Mode
fields["block_percent"] = service.Block.Percent
fields["block_usage"] = service.Block.Usage
fields["block_total"] = service.Block.Total
fields["inode_percent"] = service.Inode.Percent
fields["inode_usage"] = service.Inode.Usage
fields["inode_total"] = service.Inode.Total
acc.AddFields("monit_filesystem", fields, tags)
} else if service.Type == directory {
fields["mode"] = service.Mode
acc.AddFields("monit_directory", fields, tags)
} else if service.Type == file {
fields["size"] = service.Size
fields["mode"] = service.Mode
acc.AddFields("monit_file", fields, tags)
} else if service.Type == process {
fields["cpu_percent"] = service.CPU.Percent
fields["cpu_percent_total"] = service.CPU.PercentTotal
fields["mem_kb"] = service.Memory.Kilobyte
fields["mem_kb_total"] = service.Memory.KilobyteTotal
fields["mem_percent"] = service.Memory.Percent
fields["mem_percent_total"] = service.Memory.PercentTotal
fields["pid"] = service.Pid
fields["parent_pid"] = service.ParentPid
fields["threads"] = service.Threads
fields["children"] = service.Children
acc.AddFields("monit_process", fields, tags)
} else if service.Type == remoteHost {
fields["remote_hostname"] = service.Port.Hostname
fields["port_number"] = service.Port.PortNumber
fields["request"] = service.Port.Request
fields["protocol"] = service.Port.Protocol
fields["type"] = service.Port.Type
acc.AddFields("monit_remote_host", fields, tags)
} else if service.Type == system {
fields["cpu_system"] = service.System.CPU.System
fields["cpu_user"] = service.System.CPU.User
fields["cpu_wait"] = service.System.CPU.Wait
fields["cpu_load_avg_1m"] = service.System.Load.Avg01
fields["cpu_load_avg_5m"] = service.System.Load.Avg05
fields["cpu_load_avg_15m"] = service.System.Load.Avg15
fields["mem_kb"] = service.System.Memory.Kilobyte
fields["mem_percent"] = service.System.Memory.Percent
fields["swap_kb"] = service.System.Swap.Kilobyte
fields["swap_percent"] = service.System.Swap.Percent
acc.AddFields("monit_system", fields, tags)
} else if service.Type == fifo {
fields["mode"] = service.Mode
acc.AddFields("monit_fifo", fields, tags)
} else if service.Type == program {
fields["program_started"] = service.Program.Started * 10000000
fields["program_status"] = service.Program.Status
acc.AddFields("monit_program", fields, tags)
} else if service.Type == network {
fields["link_state"] = service.Link.State
fields["link_speed"] = service.Link.Speed
fields["link_mode"] = linkMode(service)
fields["download_packets_now"] = service.Link.Download.Packets.Now
fields["download_packets_total"] = service.Link.Download.Packets.Total
fields["download_bytes_now"] = service.Link.Download.Bytes.Now
fields["download_bytes_total"] = service.Link.Download.Bytes.Total
fields["download_errors_now"] = service.Link.Download.Errors.Now
fields["download_errors_total"] = service.Link.Download.Errors.Total
fields["upload_packets_now"] = service.Link.Upload.Packets.Now
fields["upload_packets_total"] = service.Link.Upload.Packets.Total
fields["upload_bytes_now"] = service.Link.Upload.Bytes.Now
fields["upload_bytes_total"] = service.Link.Upload.Bytes.Total
fields["upload_errors_now"] = service.Link.Upload.Errors.Now
fields["upload_errors_total"] = service.Link.Upload.Errors.Total
acc.AddFields("monit_network", fields, tags)
}
}
} else {
return fmt.Errorf("received status code %d (%s), expected 200",
resp.StatusCode,
http.StatusText(resp.StatusCode))
}
return nil
}
func linkMode(s Service) string {
if s.Link.Duplex == 1 {
return "duplex"
} else if s.Link.Duplex == 0 {
return "simplex"
} else {
return "unknown"
}
}
func serviceStatus(s Service) string {
if s.Status == 0 {
return "running"
} else {
return "failure"
}
}
func pendingAction(s Service) string {
if s.PendingAction > 0 {
if s.PendingAction >= len(pendingActions) {
return "unknown"
}
return pendingActions[s.PendingAction-1]
} else {
return "none"
}
}
func monitoringMode(s Service) string {
switch s.MonitorMode {
case 0:
return "active"
case 1:
return "passive"
}
return "unknown"
}
func monitoringStatus(s Service) string {
switch s.MonitoringStatus {
case 1:
return "monitored"
case 2:
return "initializing"
case 4:
return "waiting"
}
return "not_monitored"
}
func init() {
inputs.Add("monit", func() telegraf.Input {
return &Monit{
client: &RealHTTPClient{},
}
})
}