func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } size, err := getSqsQueueSize(opts.Region, opts.AccessKeyID, opts.SecretAccessKey, opts.QueueName) if err != nil { return checkers.NewChecker(checkers.UNKNOWN, err.Error()) } var chkSt checkers.Status var msg string if opts.Crit < size { msg = fmt.Sprintf("size %d > %d in %s", size, opts.Crit, opts.QueueName) chkSt = checkers.CRITICAL } else if opts.Warn < size { msg = fmt.Sprintf("size %d > %d in %s", size, opts.Warn, opts.QueueName) chkSt = checkers.WARNING } else { msg = fmt.Sprintf("size %d < warning %d, critical %d in %s", size, opts.Warn, opts.Crit, opts.QueueName) chkSt = checkers.OK } return checkers.NewChecker(chkSt, msg) }
func checkConnection(args []string) *checkers.Checker { opts := connectionOpts{} psr := flags.NewParser(&opts, flags.Default) psr.Usage = "connection [OPTIONS]" _, err := psr.ParseArgs(args) if err != nil { os.Exit(1) } db, err := sql.Open(opts.getDriverAndDataSourceName()) if err != nil { return checkers.Unknown(err.Error()) } defer db.Close() statActivityCount := 0 err = db.QueryRow("SELECT COUNT(*) AS cnt FROM pg_stat_activity").Scan(&statActivityCount) if err != nil { return checkers.Unknown(err.Error()) } checkSt := checkers.OK msg := fmt.Sprintf("%d connections", statActivityCount) if statActivityCount > opts.Crit { checkSt = checkers.CRITICAL } else if statActivityCount > opts.Warn { checkSt = checkers.WARNING } return checkers.NewChecker(checkSt, msg) }
func checkConnection(args []string) *checkers.Checker { opts := connectionOpts{} psr := flags.NewParser(&opts, flags.Default) psr.Usage = "connection [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 GLOBAL STATUS LIKE 'Threads_Connected'") if err != nil { return checkers.Unknown("couldn't execute query") } idxValue := res.Map("Value") threadsConnected := rows[0].Int64(idxValue) checkSt := checkers.OK msg := fmt.Sprintf("%d connections", threadsConnected) if threadsConnected > opts.Crit { checkSt = checkers.CRITICAL } else if threadsConnected > opts.Warn { checkSt = checkers.WARNING } return checkers.NewChecker(checkSt, msg) }
func checkPing(opts solrOpts) *checkers.Checker { uri := opts.createBaseURL() + "/admin/ping?wt=json" resp, err := http.Get(uri) if err != nil { return checkers.Unknown("couldn't get access to " + uri) } defer resp.Body.Close() dec := json.NewDecoder(resp.Body) var stats map[string]interface{} err = dec.Decode(&stats) if err != nil { return checkers.Unknown("couldn't parse JSON at " + uri) } status, ok := stats["status"].(string) if !ok { return checkers.Unknown("couldn't find status in JSON at " + uri) } checkSt := checkers.OK msg := fmt.Sprintf("%s %s", opts.Core, status) if status != "OK" { checkSt = checkers.CRITICAL } return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } stTime := time.Now() resp, err := http.Get(opts.URL) if err != nil { return checkers.Critical(err.Error()) } elapsed := time.Since(stTime) defer resp.Body.Close() cLength := resp.ContentLength if cLength == -1 { byt, _ := ioutil.ReadAll(resp.Body) cLength = int64(len(byt)) } checkSt := checkers.UNKNOWN switch st := resp.StatusCode; true { case st < 400: checkSt = checkers.OK case st < 500: checkSt = checkers.WARNING default: checkSt = checkers.CRITICAL } msg := fmt.Sprintf("%s %s - %d bytes in %f second respons time", resp.Proto, resp.Status, cLength, elapsed.Seconds()) return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } ut, err := uptime.Get() if err != nil { return checkers.Unknown(fmt.Sprintf("Faild to fetch uptime metrics: %s", err)) } checkSt := checkers.OK if opts.WarnUnder != nil && *opts.WarnUnder > ut { checkSt = checkers.WARNING } if opts.WarnOver != nil && *opts.WarnOver < ut { checkSt = checkers.WARNING } if opts.CritUnder != nil && *opts.CritUnder > ut { checkSt = checkers.CRITICAL } if opts.CritOver != nil && *opts.CritOver < ut { checkSt = checkers.CRITICAL } dur := time.Duration(ut * float64(time.Second)) hours := int64(dur.Hours()) days := hours / 24 hours = hours % 24 mins := int64(dur.Minutes()) % 60 msg := fmt.Sprintf("%d day(s) %d hour(s) %d minute(s) (%d second(s))\n", days, hours, mins, int64(dur.Seconds())) return checkers.NewChecker(checkSt, msg) }
func checkUptime(args []string) *checkers.Checker { opts := uptimeOpts{} psr := flags.NewParser(&opts, flags.Default) psr.Usage = "uptime [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 GLOBAL STATUS LIKE 'Uptime'") if err != nil { return checkers.Unknown("couldn't execute query") } idxValue := res.Map("Value") upTime := rows[0].Int64(idxValue) checkSt := checkers.OK msg := fmt.Sprintf("up %s", uptime2str(upTime)) if opts.Crit > 0 && upTime < opts.Crit { checkSt = checkers.CRITICAL } else if opts.Warn > 0 && upTime < 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) } 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 checkCertExpiration() *checkers.Checker { opts := certOpts{} psr := flags.NewParser(&opts, flags.Default) _, err := psr.Parse() if err != nil { psr.WriteHelp(os.Stdout) os.Exit(1) } cfByte, err := ioutil.ReadFile(opts.CertFile) if err != nil { return checkers.Critical(err.Error()) } cfBlock, _ := pem.Decode(cfByte) cfCrt, err := x509.ParseCertificate(cfBlock.Bytes) if err != nil { return checkers.Critical(err.Error()) } cfDaysRemaining := int64(cfCrt.NotAfter.Sub(time.Now().UTC()).Hours() / 24) checkSt := checkers.OK msg := fmt.Sprintf("%d days remaining", cfDaysRemaining) if cfDaysRemaining < opts.Crit { checkSt = checkers.CRITICAL } else if cfDaysRemaining < opts.Warn { checkSt = checkers.WARNING } return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { return checkers.Critical(err.Error()) } offset, err := getNtpOffset() if err != nil { return checkers.Unknown(err.Error()) } var chkSt checkers.Status var msg string if opts.Crit < math.Abs(offset) { msg = fmt.Sprintf("ntp offset is over %f(actual) > %f(threshold)", math.Abs(offset), opts.Crit) chkSt = checkers.CRITICAL } else if opts.Warn < math.Abs(offset) { msg = fmt.Sprintf("ntp offset is over %f(actual) > %f(threshold)", math.Abs(offset), opts.Warn) chkSt = checkers.WARNING } else { msg = fmt.Sprintf("ntp offset is %f(actual) < %f(warning threshold), %f(critial threshold)", offset, opts.Warn, opts.Crit) chkSt = checkers.OK } return checkers.NewChecker(chkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } ws, err := sizeValue(opts.Warn) if err != nil { return checkers.NewChecker(checkers.UNKNOWN, err.Error()) } cs, err := sizeValue(opts.Crit) if err != nil { return checkers.NewChecker(checkers.UNKNOWN, err.Error()) } var stat os.FileInfo var size int64 files, err := listFiles(opts.Base, opts.Depth) if err != nil { // file not found return checkers.NewChecker(checkers.OK, err.Error()) } for _, v := range files { stat, err = os.Stat(v) if err != nil { continue } size = size + stat.Size() } var chkSt checkers.Status var msg string if cs < float64(size) { msg = fmt.Sprintf("size %d Byte > %s Byte in %s", size, opts.Crit, opts.Base) chkSt = checkers.CRITICAL } else if ws < float64(size) { msg = fmt.Sprintf("size %d Byte > %s Byte in %s", size, opts.Warn, opts.Base) chkSt = checkers.WARNING } else { msg = fmt.Sprintf("size %d Byte < warning %s Byte, critical %s Byte in %s", size, opts.Warn, opts.Crit, opts.Base) chkSt = checkers.OK } return checkers.NewChecker(chkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } var queue int64 queueStr := "0" monitor := newMonitor(opts.Warning, opts.Critical) result := checkers.OK if opts.Mta == "postfix" { out, err := exec.Command("mailq").Output() if err != nil { return checkers.Unknown(err.Error()) } outs := strings.Split(string(out), "\n") line := outs[len(outs)-2] re := regexp.MustCompile(`-- \d+ Kbytes in (\d+) Requests.`) if re.MatchString(line) { queueStr = re.ReplaceAllString(line, "$1") queue, err = strconv.ParseInt(queueStr, 10, 64) } } else if opts.Mta == "qmail" { out, err := exec.Command("qmail-qstat").Output() if err != nil { return checkers.Unknown(err.Error()) } outs := strings.Split(string(out), "\n") line := outs[0] re := regexp.MustCompile(`^messages in queue: (\d+)`) if re.MatchString(line) { queueStr = re.ReplaceAllString(line, "$1") queue, err = strconv.ParseInt(queueStr, 10, 64) } } else { return checkers.Unknown(fmt.Sprintf("%s: specified mta's check is not implemented.", opts.Mta)) } if monitor.checkWarning(queue) { result = checkers.WARNING } if monitor.checkCritical(queue) { result = checkers.CRITICAL } msg := fmt.Sprintf(queueStr) return checkers.NewChecker(result, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } psformat := "user,pid,vsz,rss,pcpu,nlwp,state,etime,time,command" if threadsUnknown { psformat = "user,pid,vsz,rss,pcpu,state,etime,time,command" } output, err := exec.Command("ps", "axwwo", psformat).Output() var procs []procState for _, line := range strings.Split(string(output), "\n")[1:] { proc, err := parseProcState(line) if err != nil { continue } procs = append(procs, proc) } cmdPatRegexp := regexp.MustCompile(".*") if opts.CmdPat != "" { r, err := regexp.Compile(opts.CmdPat) if err != nil { os.Exit(1) } cmdPatRegexp = r } cmdExcludePatRegexp := regexp.MustCompile(".*") if opts.CmdExcludePat != "" { r, err := regexp.Compile(opts.CmdExcludePat) if err != nil { os.Exit(1) } cmdExcludePatRegexp = r } var resultrocStates []procState for _, proc := range procs { if matchProc(proc, cmdPatRegexp, cmdExcludePatRegexp) { resultrocStates = append(resultrocStates, proc) } } count := int64(len(resultrocStates)) msg := gatherMsg(count) result := checkers.OK if opts.CritUnder != 0 && count < opts.CritUnder || opts.CritOver != 0 && count > opts.CritOver { result = checkers.CRITICAL } else if opts.WarnUnder != 0 && count < opts.WarnUnder || opts.WarnOver != 0 && count > opts.WarnOver { result = checkers.WARNING } return checkers.NewChecker(result, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } // for backward compatibility if opts.WarnUnder != 1 && opts.WarningUnder == 1 { opts.WarningUnder = opts.WarnUnder } if opts.WarnOver != nil && opts.WarningOver == nil { opts.WarningOver = opts.WarnOver } procs, err := getProcs() cmdPatRegexp := regexp.MustCompile(".*") if opts.CmdPat != "" { r, err := regexp.Compile(opts.CmdPat) if err != nil { os.Exit(1) } cmdPatRegexp = r } cmdExcludePatRegexp := regexp.MustCompile(".*") if opts.CmdExcludePat != "" { r, err := regexp.Compile(opts.CmdExcludePat) if err != nil { os.Exit(1) } cmdExcludePatRegexp = r } var resultrocStates []procState for _, proc := range procs { if matchProc(proc, cmdPatRegexp, cmdExcludePatRegexp) { resultrocStates = append(resultrocStates, proc) } } count := int64(len(resultrocStates)) msg := gatherMsg(count) result := checkers.OK if opts.CritUnder != 0 && count < opts.CritUnder || opts.CritOver != nil && count > *opts.CritOver { result = checkers.CRITICAL } else if opts.WarningUnder != 0 && count < opts.WarningUnder || opts.WarningOver != nil && count > *opts.WarningOver { result = checkers.WARNING } return checkers.NewChecker(result, msg) }
func (opts *sshOpts) checkTimeout(elapsed time.Duration) *checkers.Checker { chkSt := checkers.OK if opts.Warning > 0 && elapsed > time.Duration(opts.Warning)*time.Second { chkSt = checkers.WARNING } if opts.Critical > 0 && elapsed > time.Duration(opts.Critical)*time.Second { chkSt = checkers.CRITICAL } msg := fmt.Sprintf("%.3f seconds response time on", float64(elapsed)/float64(time.Second)) if opts.Hostname != "" { msg += " " + opts.Hostname } if opts.Port > 0 { msg += fmt.Sprintf(" port %d", opts.Port) } return checkers.NewChecker(chkSt, msg) }
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 { opts, err := parseArgs(args) if err != nil { os.Exit(1) } err = opts.prepare() if err != nil { return checkers.Unknown(err.Error()) } warnNum := int64(0) critNum := int64(0) errorOverall := "" for _, f := range opts.fileList { w, c, errLines, err := opts.searchLog(f) if err != nil { return checkers.Unknown(err.Error()) } warnNum += w critNum += c if opts.ReturnContent { errorOverall += errLines } } checkSt := checkers.OK if warnNum > opts.WarnOver { checkSt = checkers.WARNING } if critNum > opts.CritOver { checkSt = checkers.CRITICAL } msg := fmt.Sprintf("%d warnings, %d criticals for pattern /%s/.", warnNum, critNum, opts.Pattern) if errorOverall != "" { msg += "\n" + errorOverall } return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { opts, err := parseArgs(args) if err != nil { os.Exit(1) } client := &http.Client{Timeout: time.Duration(opts.Timeout) * time.Second} res, err := client.Get(createURL(opts)) if err != nil { return checkers.Critical(err.Error()) } defer res.Body.Close() if res.StatusCode != http.StatusOK { return checkers.Unknown(fmt.Sprintf("failed: http status code %d", res.StatusCode)) } resJ := jmxJolokiaResponse{} dec := json.NewDecoder(res.Body) if err := dec.Decode(&resJ); err != nil { return checkers.Critical(err.Error()) } if resJ.Status != 200 { return checkers.Unknown(fmt.Sprintf("failed: response status %d", resJ.Status)) } checkSt := checkers.OK msg := fmt.Sprintf("%s %s value %f", opts.MBean, opts.Attribute, resJ.Value) if resJ.Value > opts.Critical { checkSt = checkers.CRITICAL msg = fmt.Sprintf("%s %s value is over %f > %f", opts.MBean, opts.Attribute, resJ.Value, opts.Critical) } else if resJ.Value > opts.Warning { checkSt = checkers.WARNING msg = fmt.Sprintf("%s %s value is over %f > %f", opts.MBean, opts.Attribute, resJ.Value, opts.Warning) } return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } client := &http.Client{} url := fmt.Sprintf("%s://%s:%d/_cluster/health", opts.Scheme, opts.Host, opts.Port) stTime := time.Now() resp, err := client.Get(url) if err != nil { return checkers.Critical(err.Error()) } elapsed := time.Since(stTime) defer resp.Body.Close() dec := json.NewDecoder(resp.Body) var health healthStat dec.Decode(&health) checkSt := checkers.UNKNOWN switch health.Status { case "green": checkSt = checkers.OK case "yellow": checkSt = checkers.WARNING case "red": checkSt = checkers.CRITICAL default: checkSt = checkers.UNKNOWN } msg := fmt.Sprintf("%s (cluster: %s) - %f second respons time", health.Status, health.ClusterName, elapsed.Seconds()) return checkers.NewChecker(checkSt, msg) }
func run(args []string) *checkers.Checker { _, err := flags.ParseArgs(&opts, args) if err != nil { os.Exit(1) } wload, err := parseThreshold(opts.WarningThreshold) if err != nil { return checkers.Unknown(err.Error()) } cload, err := parseThreshold(opts.CriticalThreshold) if err != nil { return checkers.Unknown(err.Error()) } loadavgs, err := getloadavg() if err != nil { return checkers.Unknown(err.Error()) } result := checkers.OK for i, load := range loadavgs { if opts.PerCPU { numCPU := runtime.NumCPU() load = load / float64(numCPU) } if load > cload[i] { result = checkers.CRITICAL break } if load > wload[i] { result = checkers.WARNING } } msg := fmt.Sprintf("load average: %.2f, %.2f, %.2f", loadavgs[0], loadavgs[1], loadavgs[2]) return checkers.NewChecker(result, msg) }
func (opts *tcpOpts) run() *checkers.Checker { err := opts.prepare() if err != nil { return checkers.Unknown(err.Error()) } // prevent changing output of some commands os.Setenv("LANG", "C") os.Setenv("LC_ALL", "C") address := fmt.Sprintf("%s:%d", opts.Hostname, opts.Port) start := time.Now() if opts.Delay > 0 { time.Sleep(time.Duration(opts.Delay) * time.Second) } var conn net.Conn if opts.UnixSock != "" { conn, err = dial("unix", opts.UnixSock, opts.SSL, opts.NoCheckCertificate) } else { conn, err = dial("tcp", address, opts.SSL, opts.NoCheckCertificate) } if err != nil { return checkers.Critical(err.Error()) } defer conn.Close() if opts.Send != "" { err := write(conn, []byte(opts.Send), opts.Timeout) if err != nil { return checkers.Critical(err.Error()) } } res := "" if opts.expectReg != nil { buf, err := slurp(conn, opts.MaxBytes, opts.Timeout) if err != nil { return checkers.Critical(err.Error()) } res = string(buf) if !opts.expectReg.MatchString(res) { return checkers.Critical("Unexpected response from host/socket: " + res) } } if opts.Quit != "" { err := write(conn, []byte(opts.Quit), opts.Timeout) if err != nil { return checkers.Critical(err.Error()) } } elapsed := time.Now().Sub(start) chkSt := checkers.OK if opts.Warning > 0 && elapsed > time.Duration(opts.Warning)*time.Second { chkSt = checkers.WARNING } if opts.Critical > 0 && elapsed > time.Duration(opts.Critical)*time.Second { chkSt = checkers.CRITICAL } msg := fmt.Sprintf("%.3f seconds response time on", float64(elapsed)/float64(time.Second)) if opts.Hostname != "" { msg += " " + opts.Hostname } if opts.Port > 0 { msg += fmt.Sprintf(" port %d", opts.Port) } if res != "" { msg += fmt.Sprintf(" [%s]", strings.Trim(res, "\r\n")) } return checkers.NewChecker(chkSt, msg) }