1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright 2018 Prometheus Team
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package cli
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/prometheus/client_golang/api"
"gopkg.in/alecthomas/kingpin.v2"
"github.com/prometheus/alertmanager/cli/format"
"github.com/prometheus/alertmanager/client"
"github.com/prometheus/alertmanager/pkg/parse"
"github.com/prometheus/alertmanager/types"
)
type silenceQueryCmd struct {
expired bool
quiet bool
matchers []string
within time.Duration
}
const querySilenceHelp = `Query Alertmanager silences.
Amtool has a simplified prometheus query syntax, but contains robust support for
bash variable expansions. The non-option section of arguments constructs a list
of "Matcher Groups" that will be used to filter your query. The following
examples will attempt to show this behaviour in action:
amtool silence query alertname=foo node=bar
This query will match all silences with the alertname=foo and node=bar label
value pairs set.
amtool silence query foo node=bar
If alertname is omitted and the first argument does not contain a '=' or a
'=~' then it will be assumed to be the value of the alertname pair.
amtool silence query 'alertname=~foo.*'
As well as direct equality, regex matching is also supported. The '=~' syntax
(similar to prometheus) is used to represent a regex match. Regex matching
can be used in combination with a direct match.
In addition to filtering by silence labels, one can also query for silences
that are due to expire soon with the "--within" parameter. In the event that
you want to preemptively act upon expiring silences by either fixing them or
extending them. For example:
amtool silence query --within 8h
returns all the silences due to expire within the next 8 hours. This syntax can
also be combined with the label based filtering above for more flexibility.
The "--expired" parameter returns only expired silences. Used in combination
with "--within=TIME", amtool returns the silences that expired within the
preceding duration.
amtool silence query --within 2h --expired
returns all silences that expired within the preceeding 2 hours.
`
func configureSilenceQueryCmd(cc *kingpin.CmdClause) {
var (
c = &silenceQueryCmd{}
queryCmd = cc.Command("query", querySilenceHelp).Default()
)
queryCmd.Flag("expired", "Show expired silences instead of active").BoolVar(&c.expired)
queryCmd.Flag("quiet", "Only show silence ids").Short('q').BoolVar(&c.quiet)
queryCmd.Arg("matcher-groups", "Query filter").StringsVar(&c.matchers)
queryCmd.Flag("within", "Show silences that will expire or have expired within a duration").DurationVar(&c.within)
queryCmd.Action(c.query)
}
func (c *silenceQueryCmd) query(ctx *kingpin.ParseContext) error {
var filterString = ""
if len(c.matchers) == 1 {
// If the parser fails then we likely don't have a (=|=~|!=|!~) so lets
// assume that the user wants alertname=<arg> and prepend `alertname=`
// to the front.
_, err := parse.Matcher(c.matchers[0])
if err != nil {
filterString = fmt.Sprintf("{alertname=%s}", c.matchers[0])
} else {
filterString = fmt.Sprintf("{%s}", strings.Join(c.matchers, ","))
}
} else if len(c.matchers) > 1 {
filterString = fmt.Sprintf("{%s}", strings.Join(c.matchers, ","))
}
apiClient, err := api.NewClient(api.Config{Address: alertmanagerURL.String()})
if err != nil {
return err
}
silenceAPI := client.NewSilenceAPI(apiClient)
fetchedSilences, err := silenceAPI.List(context.Background(), filterString)
if err != nil {
return err
}
displaySilences := []types.Silence{}
for _, silence := range fetchedSilences {
// skip expired silences if --expired is not set
if !c.expired && silence.EndsAt.Before(time.Now()) {
continue
}
// skip active silences if --expired is set
if c.expired && silence.EndsAt.After(time.Now()) {
continue
}
// skip active silences expiring after "--within"
if !c.expired && int64(c.within) > 0 && silence.EndsAt.After(time.Now().UTC().Add(c.within)) {
continue
}
// skip silences that expired before "--within"
if c.expired && int64(c.within) > 0 && silence.EndsAt.Before(time.Now().UTC().Add(-c.within)) {
continue
}
displaySilences = append(displaySilences, *silence)
}
if c.quiet {
for _, silence := range displaySilences {
fmt.Println(silence.ID)
}
} else {
formatter, found := format.Formatters[output]
if !found {
return errors.New("unknown output formatter")
}
if err := formatter.FormatSilences(displaySilences); err != nil {
return fmt.Errorf("error formatting silences: %v", err)
}
}
return nil
}
|
