本文整理汇总了Golang中bosun/org/slog.Errorf函数的典型用法代码示例。如果您正苦于以下问题:Golang Errorf函数的具体用法?Golang Errorf怎么用?Golang Errorf使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Errorf函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: DatabaseConnect
func DatabaseConnect(c conf.Database) (*sql.DB, error) {
var db *sql.DB
var err error
if c.Type == "mysql" {
if c.Password == "" {
db, err = sql.Open("mysql", c.Username+"@"+c.Protocol+"("+c.Address+":"+strconv.Itoa(c.Port)+")/")
} else {
db, err = sql.Open("mysql", c.Username+":"+c.Password+"@"+c.Protocol+"("+c.Address+":"+strconv.Itoa(c.Port)+")/")
}
}
if err != nil {
slog.Errorf("%v: %v: %v: %v", "Database", c.Type, "connect open error", err)
return nil, fmt.Errorf("%v: %v", "connect open error", err)
}
// check if can connect to database, if fail, check again every minute until connected
for {
err = db.Ping()
if err == nil {
break
}
slog.Errorf("%v: %v: %v: %v", "Database", c.Type, "connect ping error", err)
next := time.After(time.Minute)
select {
case <-next:
case <-ContinuousCollectorVars.quit:
db.Close()
return nil, fmt.Errorf("connect while quitting")
}
}
return db, nil
}
示例2: Command
// Command executes the named program with the given arguments. If it does not
// exit within timeout, it is sent SIGINT (if supported by Go). After
// another timeout, it is killed.
func Command(timeout time.Duration, stdin io.Reader, name string, arg ...string) (io.Reader, error) {
if _, err := exec.LookPath(name); err != nil {
return nil, ErrPath
}
if Debug {
slog.Infof("executing command: %v %v", name, arg)
}
c := exec.Command(name, arg...)
b := &bytes.Buffer{}
c.Stdout = b
c.Stdin = stdin
if err := c.Start(); err != nil {
return nil, err
}
timedOut := false
intTimer := time.AfterFunc(timeout, func() {
slog.Errorf("Process taking too long. Interrupting: %s %s", name, strings.Join(arg, " "))
c.Process.Signal(os.Interrupt)
timedOut = true
})
killTimer := time.AfterFunc(timeout*2, func() {
slog.Errorf("Process taking too long. Killing: %s %s", name, strings.Join(arg, " "))
c.Process.Signal(os.Kill)
timedOut = true
})
err := c.Wait()
intTimer.Stop()
killTimer.Stop()
if timedOut {
return nil, ErrTimeout
}
return b, err
}
示例3: save
func (s *Schedule) save() {
if s.db == nil {
return
}
s.Lock("Save")
store := map[string]interface{}{
dbMetric: s.Search.Read.Metric,
dbTagk: s.Search.Read.Tagk,
dbTagv: s.Search.Read.Tagv,
dbMetricTags: s.Search.Read.MetricTags,
dbNotifications: s.Notifications,
dbSilence: s.Silence,
dbStatus: s.status,
dbMetadata: s.Metadata,
dbIncidents: s.Incidents,
}
tostore := make(map[string][]byte)
for name, data := range store {
f := new(bytes.Buffer)
gz := gzip.NewWriter(f)
cw := &counterWriter{w: gz}
enc := gob.NewEncoder(cw)
if err := enc.Encode(data); err != nil {
slog.Errorf("error saving %s: %v", name, err)
s.Unlock()
return
}
if err := gz.Flush(); err != nil {
slog.Errorf("gzip flush error saving %s: %v", name, err)
}
if err := gz.Close(); err != nil {
slog.Errorf("gzip close error saving %s: %v", name, err)
}
tostore[name] = f.Bytes()
slog.Infof("wrote %s: %v", name, conf.ByteSize(cw.written))
collect.Put("statefile.size", opentsdb.TagSet{"object": name}, cw.written)
}
s.Unlock()
err := s.db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte(dbBucket))
if err != nil {
return err
}
for name, data := range tostore {
if err := b.Put([]byte(name), data); err != nil {
return err
}
}
return nil
})
if err != nil {
slog.Errorf("save db update error: %v", err)
return
}
fi, err := os.Stat(s.Conf.StateFile)
if err == nil {
collect.Put("statefile.size", opentsdb.TagSet{"object": "total"}, fi.Size())
}
slog.Infoln("save to db complete")
}
示例4: add
// structProcessor.add() takes in a metric name prefix, an arbitrary struct, and a tagset.
// The processor recurses through the struct and builds metrics. The field tags direct how
// the field should be processed, as well as the metadata for the resulting metric.
//
// The field tags used are described as follows:
//
// version: typically set to '1' or '2'.
// This is compared against the elastic cluster version. If the version from the tag
// does not match the version in production, the metric will not be sent for this field.
//
// exclude:
// If this tag is set to 'true', a metric will not be sent for this field.
//
// rate: one of 'gauge', 'counter', 'rate'
// This tag dictates the metadata.RateType we send.
//
// unit: 'bytes', 'pages', etc
// This tag dictates the metadata.Unit we send.
//
// metric:
// This is the metric name which will be sent. If not present, the 'json'
// tag is sent as the metric name.
//
// Special handling:
//
// Metrics having the json tag suffix of 'in_milliseconds' are automagically
// divided by 1000 and sent as seconds. The suffix is stripped from the name.
//
// Metrics having the json tag suffix of 'in_bytes' are automatically sent as
// gauge bytes. The suffix is stripped from the metric name.
func (s *structProcessor) add(prefix string, st interface{}, ts opentsdb.TagSet) {
t := reflect.TypeOf(st)
valueOf := reflect.ValueOf(st)
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
value := valueOf.Field(i).Interface()
if field.Tag.Get("exclude") == "true" {
continue
}
var (
jsonTag = field.Tag.Get("json")
metricTag = field.Tag.Get("metric")
versionTag = field.Tag.Get("version")
rateTag = field.Tag.Get("rate")
unitTag = field.Tag.Get("unit")
)
metricName := jsonTag
if metricTag != "" {
metricName = metricTag
}
if metricName == "" {
slog.Errorf("Unable to determine metric name for field %s. Skipping.", field.Name)
continue
}
if versionTag == "" || strings.HasPrefix(s.elasticVersion, versionTag) {
switch value := value.(type) {
case int, float64: // Number types in our structs are only ints and float64s.
// Turn all millisecond metrics into seconds
if strings.HasSuffix(metricName, "_in_millis") {
switch value.(type) {
case int:
value = float64(value.(int)) / 1000
case float64:
value = value.(float64) / 1000
}
unitTag = "seconds"
metricName = strings.TrimSuffix(metricName, "_in_millis")
}
// Set rate and unit for all "_in_bytes" metrics, and strip the "_in_bytes"
if strings.HasSuffix(metricName, "_in_bytes") {
if rateTag == "" {
rateTag = "gauge"
}
unitTag = "bytes"
metricName = strings.TrimSuffix(metricName, "_in_bytes")
}
Add(s.md, prefix+"."+metricName, value, ts, metadata.RateType(rateTag), metadata.Unit(unitTag), field.Tag.Get("desc"))
case string:
// The json data has a lot of strings, and we don't care about em.
default:
// If we hit another struct, recurse
if reflect.ValueOf(value).Kind() == reflect.Struct {
s.add(prefix+"."+metricName, value, ts)
} else {
slog.Errorf("Field %s for metric %s is non-numeric type. Cannot record as a metric.\n", field.Name, prefix+"."+metricName)
}
}
}
}
}
示例5: runService
func runService(name string, isDebug bool) {
errFix := fixEventMessageFile(name) //Temp fix. Remove after a few weeks.
if errFix != nil {
slog.Errorf("%s fixEventMessageFile failed: %v", name, errFix)
return
}
if isDebug {
slog.SetEventLog(debug.New(name), 1)
} else {
elog, err := eventlog.Open(name)
if err != nil {
return
}
slog.SetEventLog(elog, 1)
defer elog.Close()
}
slog.Infof("starting %s service version %v (%v)", name, version.Version, version.VersionSHA)
run := svc.Run
if isDebug {
run = debug.Run
}
err := run(name, &s{})
if err != nil {
slog.Errorf("%s service failed: %v", name, err)
return
}
slog.Infof("%s service stopped", name)
os.Exit(0)
}
示例6: c_redis_counters
func c_redis_counters(server string, db int) (opentsdb.MultiDataPoint, error) {
var md opentsdb.MultiDataPoint
conn, err := redis.Dial("tcp", server, redis.DialDatabase(db))
if err != nil {
return md, err
}
defer conn.Close()
if _, err := conn.Do("CLIENT", "SETNAME", "scollector"); err != nil {
return md, err
}
cursor := 0
for {
vals, err := redis.Values(conn.Do("HSCAN", collect.RedisCountersKey, cursor))
if err != nil {
return md, err
}
if len(vals) != 2 {
return md, fmt.Errorf("Unexpected number of values")
}
cursor, err = redis.Int(vals[0], nil)
if err != nil {
return md, err
}
pairs, err := redis.StringMap(vals[1], nil)
if err != nil {
return md, err
}
for mts, val := range pairs {
parts := strings.Split(mts, ":")
if len(parts) != 2 {
slog.Errorf("Invalid metric tag set counter: %s", mts)
continue
}
metric := parts[0]
tags, err := opentsdb.ParseTags(parts[1])
if err != nil {
slog.Errorf("Invalid tags: %s", parts[1])
continue
}
v, err := strconv.Atoi(val)
if err != nil {
slog.Errorf("Invalid counter value: %s", val)
continue
}
Add(&md, metric, v, tags, metadata.Counter, metadata.Count, "")
}
if cursor == 0 {
break
}
}
return md, nil
}
示例7: PutMetadata
func (s *Schedule) PutMetadata(k metadata.Metakey, v interface{}) {
isCoreMeta := (k.Name == "desc" || k.Name == "unit" || k.Name == "rate")
if !isCoreMeta {
s.metaLock.Lock()
s.Metadata[k] = &Metavalue{time.Now().UTC(), v}
s.metaLock.Unlock()
return
}
if k.Metric == "" {
slog.Error("desc, rate, and unit require metric name")
return
}
strVal, ok := v.(string)
if !ok {
slog.Errorf("desc, rate, and unit require value to be string. Found: %s", reflect.TypeOf(v))
return
}
s.metricMetaLock.Lock()
metricData, ok := s.metricMetadata[k.Metric]
if !ok {
metricData = &MetadataMetric{}
s.metricMetadata[k.Metric] = metricData
}
switch k.Name {
case "desc":
metricData.Description = strVal
case "unit":
metricData.Unit = strVal
case "rate":
metricData.Type = strVal
}
s.metricMetaLock.Unlock()
}
示例8: timeTSDBRequest
func timeTSDBRequest(e *State, T miniprofiler.Timer, req *opentsdb.Request) (s opentsdb.ResponseSet, err error) {
e.tsdbQueries = append(e.tsdbQueries, *req)
if e.autods > 0 {
for _, q := range req.Queries {
if q.Downsample == "" {
if err := req.AutoDownsample(e.autods); err != nil {
return nil, err
}
}
}
}
b, _ := json.MarshalIndent(req, "", " ")
tries := 1
for {
T.StepCustomTiming("tsdb", "query", string(b), func() {
getFn := func() (interface{}, error) {
return e.tsdbContext.Query(req)
}
var val interface{}
val, err = e.cache.Get(string(b), getFn)
s = val.(opentsdb.ResponseSet).Copy()
})
if err == nil || tries == tsdbMaxTries {
break
}
slog.Errorf("Error on tsdb query %d: %s", tries, err.Error())
tries++
}
return
}
示例9: CheckAlert
func (s *Schedule) CheckAlert(T miniprofiler.Timer, r *RunHistory, a *conf.Alert) {
slog.Infof("check alert %v start", a.Name)
start := utcNow()
for _, ak := range s.findUnknownAlerts(r.Start, a.Name) {
r.Events[ak] = &models.Event{Status: models.StUnknown}
}
var warns, crits models.AlertKeys
d, err := s.executeExpr(T, r, a, a.Depends)
var deps expr.ResultSlice
if err == nil {
deps = filterDependencyResults(d)
crits, err = s.CheckExpr(T, r, a, a.Crit, models.StCritical, nil)
if err == nil {
warns, err = s.CheckExpr(T, r, a, a.Warn, models.StWarning, crits)
}
}
unevalCount, unknownCount := markDependenciesUnevaluated(r.Events, deps, a.Name)
if err != nil {
slog.Errorf("Error checking alert %s: %s", a.Name, err.Error())
removeUnknownEvents(r.Events, a.Name)
s.markAlertError(a.Name, err)
} else {
s.markAlertSuccessful(a.Name)
}
collect.Put("check.duration", opentsdb.TagSet{"name": a.Name}, time.Since(start).Seconds())
slog.Infof("check alert %v done (%s): %v crits, %v warns, %v unevaluated, %v unknown", a.Name, time.Since(start), len(crits), len(warns), unevalCount, unknownCount)
}
示例10: init
func init() {
registerInit(func(c *conf.Conf) {
for _, filter := range c.ElasticIndexFilters {
err := AddElasticIndexFilter(filter)
if err != nil {
slog.Errorf("Error processing ElasticIndexFilter: %s", err)
}
}
collectors = append(collectors, &IntervalCollector{
F: func() (opentsdb.MultiDataPoint, error) {
return c_elasticsearch(false)
},
name: "elasticsearch",
Enable: enableURL("http://localhost:9200/"),
})
collectors = append(collectors, &IntervalCollector{
F: func() (opentsdb.MultiDataPoint, error) {
return c_elasticsearch(true)
},
name: "elasticsearch-indices",
Interval: time.Minute * 15,
Enable: enableURL("http://localhost:9200/"),
})
})
}
示例11: findUnknownAlerts
func (s *Schedule) findUnknownAlerts(now time.Time, alert string) []models.AlertKey {
keys := []models.AlertKey{}
if utcNow().Sub(bosunStartupTime) < s.SystemConf.GetCheckFrequency() {
return keys
}
if !s.AlertSuccessful(alert) {
return keys
}
a := s.RuleConf.GetAlert(alert)
t := a.Unknown
if t == 0 {
runEvery := s.SystemConf.GetDefaultRunEvery()
if a.RunEvery != 0 {
runEvery = a.RunEvery
}
t = s.SystemConf.GetCheckFrequency() * 2 * time.Duration(runEvery)
}
maxTouched := now.UTC().Unix() - int64(t.Seconds())
untouched, err := s.DataAccess.State().GetUntouchedSince(alert, maxTouched)
if err != nil {
slog.Errorf("Error finding unknown alerts for alert %s: %s.", alert, err)
return keys
}
for _, ak := range untouched {
if a.Squelch.Squelched(ak.Group()) {
continue
}
keys = append(keys, ak)
}
return keys
}
示例12: c_fastly
func c_fastly(c fastlyClient) (opentsdb.MultiDataPoint, error) {
var md opentsdb.MultiDataPoint
to := time.Now().UTC().Truncate(time.Minute)
from := to.Add(-15 * time.Minute) // "Minutely data will be delayed by roughly 10 to 15 minutes from the current time -- Fastly Docs"
// Aggregate
statsCollection, err := c.GetAggregateStats(from, to)
if err != nil {
return md, err
}
for _, stats := range statsCollection {
fastlyReflectAdd(&md, "fastly", "", stats, stats.StartTime, nil)
}
// By Service
services, err := c.GetServices()
if err != nil {
return md, err
}
for _, service := range services {
statsCollection, err := c.GetServiceStats(from, to, service.Id)
if err != nil {
slog.Errorf("couldn't get stats for service %v with id %v: %v", service.Name, service.Id, err)
continue
}
for _, stats := range statsCollection {
fastlyReflectAdd(&md, "fastly", "_by_service", stats, stats.StartTime, service.TagSet())
}
}
// By Region
regions, err := c.GetRegions()
if err != nil {
return md, err
}
for _, region := range regions {
statsCollection, err := c.GetRegionStats(from, to, region)
if err != nil {
slog.Errorf("couldn't get stats for region %v: %v", region, err)
continue
}
for _, stats := range statsCollection {
fastlyReflectAdd(&md, "fastly", "_by_region", stats, stats.StartTime, region.TagSet())
}
}
return md, nil
}
示例13: incrementRedisCounter
func incrementRedisCounter(data []byte, addr string, conn redis.Conn) {
if len(data) < 5 {
slog.Errorf("Insufficient data for increment from %s.", addr)
return
}
r := bytes.NewReader(data)
var i int32
err := binary.Read(r, binary.BigEndian, &i)
if err != nil {
slog.Error(err)
return
}
mts := string(data[4:])
if _, err = conn.Do("HINCRBY", RedisCountersKey, mts, i); err != nil {
slog.Errorf("Error incrementing counter %s by %d. From %s. %s", mts, i, addr, err)
}
}
示例14: GetUnknownAndUnevaluatedAlertKeys
func (s *Schedule) GetUnknownAndUnevaluatedAlertKeys(alert string) (unknown, uneval []models.AlertKey) {
unknown, uneval, err := s.DataAccess.State().GetUnknownAndUnevalAlertKeys(alert)
if err != nil {
slog.Errorf("Error getting unknown/unevaluated alert keys: %s", err)
return nil, nil
}
return unknown, uneval
}
示例15: snmp_subtree
// snmp_subtree takes an oid and returns all data exactly one level below it. It
// produces an error if there is more than one level below.
func snmp_subtree(host, community, oid string) (map[string]interface{}, error) {
rows, err := snmp.Walk(host, community, oid)
if err != nil {
return nil, err
}
m := make(map[string]interface{})
for rows.Next() {
key := ""
var a interface{}
switch oid {
case ifHCInBroadcastPkts:
a = new(big.Int)
id, err := rows.Scan(&a)
if err != nil {
slog.Errorf("Error scanning oid %v on host %v: %v", oid, host, err)
continue
}
switch t := id.(type) {
case int:
key = fmt.Sprint(t)
default:
return nil, fmt.Errorf("snmp subtree: only one level allowed")
}
default:
id, err := rows.Scan(&a)
if err != nil {
slog.Errorf("Error scanning oid %v on host %v: %v", oid, host, err)
continue
}
switch t := id.(type) {
case int:
key = fmt.Sprint(t)
case []int:
key = snmpOidArrayToString(t)
default:
return nil, fmt.Errorf("Unknown key type: %s", reflect.TypeOf(id).String())
}
}
m[key] = a
}
if err := rows.Err(); err != nil && err != io.EOF {
return nil, err
}
return m, nil
}