小花狸监控之Redis

五郎.

小花狸监控Redis和主机的状态　　
　　监控主机状态的代码
　　$GOPATH/src/probe/module/Host.go
　　
　　package module
　　
　　import (
　　"io/ioutil"
　　"net"
　　"os/exec"
　　"strconv"
　　"strings"
　　"syscall"
　　"time"
　　)
　　
　　type Disk struct {
　　Name string `json:name`
　　All  uint64 `json:all`
　　Used uint64 `json:used`
　　Free uint64 `json:free`
　　}
　　
　　func (this *Disk) DiskUsage() {
　　fs := syscall.Statfs_t{}
　　err := syscall.Statfs(this.Name, &fs)
　　if err != nil {
　　this.All = 0
　　this.Free = 0
　　this.Used = 0
　　}
　　this.All = fs.Blocks * uint64(fs.Bsize)
　　this.Free = fs.Bavail * uint64(fs.Bsize)
　　this.Used = this.All - fs.Bfree*uint64(fs.Bsize)
　　}
　　
　　type Memory struct {
　　AllMemory  uint64 `json:allmemory`
　　UsedMemory uint64 `json:usedmemory`
　　FreeMemory uint64 `json:freememory`
　　}
　　
　　func (this *Memory) MemoryUsage() {
　　cmd := exec.Command("/bin/bash", "-c", `free -m | awk 'NR==3 {print $3"TAB"$4}'`)
　　stdout, _ := cmd.StdoutPipe()
　　cmd.Start()
　　bytes, _ := ioutil.ReadAll(stdout)
　　data := strings.Split(string(bytes), "TAB")
　　this.UsedMemory, _ = strconv.ParseUint(data[0], 10, 64)
　　this.FreeMemory, _ = strconv.ParseUint(strings.Trim(data[1], "\n"), 10, 64)
　　this.AllMemory = this.UsedMemory + this.FreeMemory
　　}
　　
　　type Host struct {
　　Ip     string
　　Root   Disk `json:root`
　　Data   Disk `json:data`
　　Dbdata Disk `json:dbdata`
　　Memory
　　Cpu
　　Ts time.Time `json:ts`
　　}
　　
　　func getHostAddr() (hostAddr string) {
　　addrs, _ := net.InterfaceAddrs()
　　for _, addr := range addrs {
　　ip := addr.String()
　　if !strings.HasPrefix(ip, "127") && !strings.HasPrefix(ip, "192") && !strings.HasSuffix(ip, "128") && !strings.HasSuffix(ip, "64") {
　　return ip[0:strings.LastIndex(ip, "/")]
　　}
　　}
　　return "127.0.0.1"
　　}
　　
　　func (this *Host) HostUsage() {
　　this.Ip = getHostAddr()
　　this.MemoryUsage()
　　this.Root.DiskUsage()
　　this.Data.DiskUsage()
　　this.Dbdata.DiskUsage()
　　this.Cpu.CpuUsage()
　　}
　　
　　
　　type Cpu struct {
　　CpuIdle float64
　　}
　　
　　func (this *Cpu) CpuUsage() {
　　cmd := exec.Command("/bin/bash", "-c", `top -b -n 1 | grep Cpu | awk -F"," '{print $4}' | sed 's/%id//g;s/^ //g'`)
　　stdout, _ := cmd.StdoutPipe()
　　cmd.Start()
　　bytes, _ := ioutil.ReadAll(stdout)
　　cpuidle, _ := strconv.ParseFloat(strings.Trim(string(bytes), "\n"), 64)
　　this.CpuIdle = cpuidle
　　}
　　
　　func NewHost(host *Host) {
　　host.Root = Disk{Name: "/"}
　　host.Data = Disk{Name: "/data"}
　　host.Dbdata = Disk{Name: "/dbdata"}
　　host.Ts = time.Now()
　　host.HostUsage()
　　}
　　
　　监控Redis的代码
　　$GOLANG/src/probe/module/Redis.go
　　
　　通过反射的方式,监控Redis信息
　　
　　package module
　　
　　import (
　　"github.com/garyburd/redigo/redis"
　　"io/ioutil"
　　"os/exec"
　　"reflect"
　　"strconv"
　　"strings"
　　"time"
　　)
　　
　　type RedisInfo struct {
　　Port                       string
　　Connected_clients          int64
　　Blocked_clients            int64
　　Used_memory                int64
　　Role                       string
　　Instantaneous_ops_per_sec  int64
　　Rejected_connections       int64
　　Master_host                string
　　Master_port                int64
　　Master_link_status         string
　　Master_last_io_seconds_ago int64
　　Connected_slaves           int64
　　Cpu_ratio                  float64
　　Master0                    string
　　Host                       Host
　　}
　　
　　func GetRedisInfo(port string, password string) (redisinfo *RedisInfo) {
　　r := &RedisInfo{}
　　NewHost(&r.Host)
　　r.Port = port
　　ref := reflect.ValueOf(r)
　　conn, _ := redis.DialTimeout("tcp", ":"+port, 0, 1*time.Second, 1*time.Second)
　　conn.Do("AUTH", password)
　　defer conn.Close()
　　info, _ := redis.String(conn.Do("info"))
　　data := strings.Split(info, "\n")
　　for _, v := range data {
　　if !strings.HasPrefix(v, "#") && !strings.HasPrefix(v, "\r") && strings.Contains(v, ":") {
　　result := strings.Split(v, ":")
　　field := ref.Elem().FieldByName(strings.Title(result[0]))
　　if field.IsValid() {
　　switch field.Kind() {
　　case reflect.Int64:
　　val, _ := strconv.ParseInt(strings.Trim(result[1], "\r"), 10, 64)
　　field.SetInt(val)
　　case reflect.String:
　　field.SetString(strings.Trim(result[1], "\r"))
　　}
　　}
　　}
　　}
　　r.Cpu_ratio = getCpuInfo(port)
　　return r
　　}
　　
　　
　　func getCpuInfo(port string) float64 {
　　cmd := exec.Command("/bin/bash", "-c", `top -b -n 1 -p $(ps -ef | grep  -w "redis-server\ \*:`+port+`" | awk '{print $2}') | awk '/redis-server/{print $9}' | sed 's/\r//g'`)
　　stdout, _ := cmd.StdoutPipe()
　　cmd.Start()
　　bytes, _ := ioutil.ReadAll(stdout)
　　cpuinfo, _ := strconv.ParseFloat(strings.Trim(string(bytes), "\n"), 64)
　　return cpuinfo
　　}
　　
　　
　　调用$GOPATH/src/main.go
　　package main
　　
　　import (
　　"encoding/json"
　　"log"
　　"probe/module"
　　)
　　
　　func main() {
　　r := module.GetRedisInfo("30000", "")
　　result, _ := json.Marshal(*r)
　　log.Println(string(result))
　　}
　　
　　结果
　　{
　　"Port": "30000", 
　　"Connected_clients": 3, 
　　"Blocked_clients": 0, 
　　"Used_memory": 852208, 
　　"Role": "master", 
　　"Instantaneous_ops_per_sec": 0, 
　　"Rejected_connections": 0, 
　　"Master_host": "", 
　　"Master_port": 0, 
　　"Master_link_status": "", 
　　"Master_last_io_seconds_ago": 0, 
　　"Connected_slaves": 0, 
　　"Cpu_ratio": 0, 
　　"Master0": "", 
　　"Host": {
　　"Ip": "172.16.1.78", 
　　"Root": {
　　"Name": "/", 
　　"All": 50519138304, 
　　"Used": 6745673728, 
　　"Free": 41207181312
　　}, 
　　"Data": {
　　"Name": "/data", 
　　"All": 50519138304, 
　　"Used": 6745673728, 
　　"Free": 41207181312
　　}, 
　　"Dbdata": {
　　"Name": "/dbdata", 
　　"All": 0, 
　　"Used": 0, 
　　"Free": 0
　　}, 
　　"AllMemory": 7872, 
　　"UsedMemory": 947, 
　　"FreeMemory": 6925, 
　　"CpuIdle": 99.9, 
　　"Ts": "2015-03-19T19:08:23.780288023+08:00"
　　}
　　}