func checkUptime() *checkers.Checker { opts := connectionOpts{} psr := flags.NewParser(&opts, flags.Default) _, err := psr.Parse() if err != nil { os.Exit(1) } db := mysql.New("tcp", "", fmt.Sprintf("%s:%s", opts.mysqlSetting.Host, opts.mysqlSetting.Port), opts.mysqlSetting.User, opts.mysqlSetting.Pass, "") err = db.Connect() if err != nil { return checkers.Critical("couldn't connect DB") } defer db.Close() rows, res, err := db.Query("SHOW GLOBAL STATUS LIKE 'Uptime'") if err != nil { return checkers.Critical("couldn't execute query") } idxValue := res.Map("Value") Uptime := rows[0].Int64(idxValue) if opts.Crit > 0 && Uptime < opts.Crit { return checkers.Critical(fmt.Sprintf("up %s < %s", uptime2str(Uptime), uptime2str(opts.Crit))) } else if opts.Warn > 0 && Uptime < opts.Warn { return checkers.Warning(fmt.Sprintf("up %s < %s", uptime2str(Uptime), uptime2str(opts.Warn))) } return checkers.Ok(fmt.Sprintf("up %s", uptime2str(Uptime))) }
func (opts *options) run() *checkers.Checker { missingInstances, missingMembers, err := check(opts) if err != nil { return checkers.Unknown(err.Error()) } if len(missingInstances) != 0 { var ipAddrs []string for _, instance := range missingInstances { ipAddrs = append(ipAddrs, aws.StringValue(instance.PrivateIpAddress)) } return checkers.Critical(fmt.Sprintf("%d instance(s) left from Consul cluster: %v", len(ipAddrs), ipAddrs)) } if len(missingMembers) != 0 { var ipAddrs []string for _, member := range missingMembers { ipAddrs = append(ipAddrs, fmt.Sprintf("%s(%s)", member.Node, member.Address)) } return checkers.Warning(fmt.Sprintf("%d instance(s) not properly tagged: %v", len(ipAddrs), ipAddrs)) } return checkers.Ok("OK") }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } stat, err := os.Stat(opts.File) if err != nil { if opts.IgnoreMissing { return checkers.Ok("No such file, but ignore missing is set.") } return checkers.Unknown(err.Error()) } monitor := newMonitor(opts.WarningAge, opts.WarningSize, opts.CriticalAge, opts.CriticalSize) result := checkers.OK mtime := stat.ModTime() age := time.Now().Unix() - mtime.Unix() size := stat.Size() if monitor.CheckWarning(age, size) { result = checkers.WARNING } if monitor.CheckCritical(age, size) { result = checkers.CRITICAL } msg := fmt.Sprintf("%s is %d seconds old (%02d:%02d:%02d) and %d bytes.\n", opts.File, age, mtime.Hour(), mtime.Minute(), mtime.Second(), size) return checkers.NewChecker(result, msg) }
func checkSlave(args []string) *checkers.Checker { opts := redisSetting{} psr := flags.NewParser(&opts, flags.Default) psr.Usage = "slave [OPTIONS]" _, err := psr.ParseArgs(args) if err != nil { fmt.Println(err) os.Exit(1) } c, info, err := connectRedisGetInfo(opts) if err != nil { return checkers.Unknown(err.Error()) } defer c.Close() if status, ok := (*info)["master_link_status"]; ok { msg := fmt.Sprintf("master_link_status: %s", status) switch status { case "up": return checkers.Ok(msg) case "down": return checkers.Critical(msg) default: return checkers.Unknown(msg) } } else { // it may be a master! return checkers.Unknown("couldn't get master_link_status") } }
func checkReplication(args []string) *checkers.Checker { opts := replicationOpts{} psr := flags.NewParser(&opts, flags.Default) psr.Usage = "replication [OPTIONS]" _, err := psr.ParseArgs(args) if err != nil { os.Exit(1) } db := newMySQL(opts.mysqlSetting) err = db.Connect() if err != nil { return checkers.Unknown("couldn't connect DB") } defer db.Close() rows, res, err := db.Query("SHOW SLAVE STATUS") if err != nil { return checkers.Unknown("couldn't execute query") } if len(rows) == 0 { return checkers.Ok("MySQL is not slave") } idxIoThreadRunning := res.Map("Slave_IO_Running") idxSQLThreadRunning := res.Map("Slave_SQL_Running") idxSecondsBehindMaster := res.Map("Seconds_Behind_Master") ioThreadStatus := rows[0].Str(idxIoThreadRunning) sqlThreadStatus := rows[0].Str(idxSQLThreadRunning) secondsBehindMaster := rows[0].Int64(idxSecondsBehindMaster) if !(ioThreadStatus == "Yes" && sqlThreadStatus == "Yes") { return checkers.Critical("MySQL replication has been stopped") } checkSt := checkers.OK msg := fmt.Sprintf("MySQL replication behind master %d seconds", secondsBehindMaster) if secondsBehindMaster > opts.Crit { checkSt = checkers.CRITICAL } else if secondsBehindMaster > opts.Warn { checkSt = checkers.WARNING } return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } mc := memcache.New(opts.Host + ":" + opts.Port) mc.Timeout = time.Duration(opts.Timeout) * time.Second err = mc.Set(&memcache.Item{Key: opts.Key, Value: []byte("Check key"), Expiration: 240}) if err != nil { return checkers.Critical("couldn't set a key: " + err.Error()) } item, err := mc.Get(opts.Key) if err != nil { return checkers.Critical("couldn't get a key: " + err.Error()) } if string(item.Value) != "Check key" { return checkers.Critical("not correct value") } return checkers.Ok("Get,Set OK") }
func checkReachable(args []string) *checkers.Checker { opts := redisSetting{} psr := flags.NewParser(&opts, flags.Default) psr.Usage = "reachable [OPTIONS]" _, err := psr.ParseArgs(args) if err != nil { fmt.Println(err) os.Exit(1) } c, info, err := connectRedisGetInfo(opts) if err != nil { return checkers.Unknown(err.Error()) } defer c.Close() if _, ok := (*info)["redis_version"]; !ok { return checkers.Unknown("couldn't get redis_version") } return checkers.Ok( fmt.Sprintf("version: %s", (*info)["redis_version"]), ) }