cmd/bpa-operator/vendor/github.com/prometheus/common/model/alert.go

   1 // Copyright 2013 The Prometheus Authors
   2 // Licensed under the Apache License, Version 2.0 (the "License");
   3 // you may not use this file except in compliance with the License.
   4 // You may obtain a copy of the License at
   5 //
   6 // http://www.apache.org/licenses/LICENSE-2.0
   7 //
   8 // Unless required by applicable law or agreed to in writing, software
   9 // distributed under the License is distributed on an "AS IS" BASIS,
  10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 // See the License for the specific language governing permissions and
  12 // limitations under the License.
  13
  14 package model
  15
  16 import (
  17         "fmt"
  18         "time"
  19 )
  20
  21 type AlertStatus string
  22
  23 const (
  24         AlertFiring   AlertStatus = "firing"
  25         AlertResolved AlertStatus = "resolved"
  26 )
  27
  28 // Alert is a generic representation of an alert in the Prometheus eco-system.
  29 type Alert struct {
  30         // Label value pairs for purpose of aggregation, matching, and disposition
  31         // dispatching. This must minimally include an "alertname" label.
  32         Labels LabelSet `json:"labels"`
  33
  34         // Extra key/value information which does not define alert identity.
  35         Annotations LabelSet `json:"annotations"`
  36
  37         // The known time range for this alert. Both ends are optional.
  38         StartsAt     time.Time `json:"startsAt,omitempty"`
  39         EndsAt       time.Time `json:"endsAt,omitempty"`
  40         GeneratorURL string    `json:"generatorURL"`
  41 }
  42
  43 // Name returns the name of the alert. It is equivalent to the "alertname" label.
  44 func (a *Alert) Name() string {
  45         return string(a.Labels[AlertNameLabel])
  46 }
  47
  48 // Fingerprint returns a unique hash for the alert. It is equivalent to
  49 // the fingerprint of the alert's label set.
  50 func (a *Alert) Fingerprint() Fingerprint {
  51         return a.Labels.Fingerprint()
  52 }
  53
  54 func (a *Alert) String() string {
  55         s := fmt.Sprintf("%s[%s]", a.Name(), a.Fingerprint().String()[:7])
  56         if a.Resolved() {
  57                 return s + "[resolved]"
  58         }
  59         return s + "[active]"
  60 }
  61
  62 // Resolved returns true iff the activity interval ended in the past.
  63 func (a *Alert) Resolved() bool {
  64         return a.ResolvedAt(time.Now())
  65 }
  66
  67 // ResolvedAt returns true off the activity interval ended before
  68 // the given timestamp.
  69 func (a *Alert) ResolvedAt(ts time.Time) bool {
  70         if a.EndsAt.IsZero() {
  71                 return false
  72         }
  73         return !a.EndsAt.After(ts)
  74 }
  75
  76 // Status returns the status of the alert.
  77 func (a *Alert) Status() AlertStatus {
  78         if a.Resolved() {
  79                 return AlertResolved
  80         }
  81         return AlertFiring
  82 }
  83
  84 // Validate checks whether the alert data is inconsistent.
  85 func (a *Alert) Validate() error {
  86         if a.StartsAt.IsZero() {
  87                 return fmt.Errorf("start time missing")
  88         }
  89         if !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) {
  90                 return fmt.Errorf("start time must be before end time")
  91         }
  92         if err := a.Labels.Validate(); err != nil {
  93                 return fmt.Errorf("invalid label set: %s", err)
  94         }
  95         if len(a.Labels) == 0 {
  96                 return fmt.Errorf("at least one label pair required")
  97         }
  98         if err := a.Annotations.Validate(); err != nil {
  99                 return fmt.Errorf("invalid annotations: %s", err)
 100         }
 101         return nil
 102 }
 103
 104 // Alert is a list of alerts that can be sorted in chronological order.
 105 type Alerts []*Alert
 106
 107 func (as Alerts) Len() int      { return len(as) }
 108 func (as Alerts) Swap(i, j int) { as[i], as[j] = as[j], as[i] }
 109
 110 func (as Alerts) Less(i, j int) bool {
 111         if as[i].StartsAt.Before(as[j].StartsAt) {
 112                 return true
 113         }
 114         if as[i].EndsAt.Before(as[j].EndsAt) {
 115                 return true
 116         }
 117         return as[i].Fingerprint() < as[j].Fingerprint()
 118 }
 119
 120 // HasFiring returns true iff one of the alerts is not resolved.
 121 func (as Alerts) HasFiring() bool {
 122         for _, a := range as {
 123                 if !a.Resolved() {
 124                         return true
 125                 }
 126         }
 127         return false
 128 }
 129
 130 // Status returns StatusFiring iff at least one of the alerts is firing.
 131 func (as Alerts) Status() AlertStatus {
 132         if as.HasFiring() {
 133                 return AlertFiring
 134         }
 135         return AlertResolved
 136 }