File size: 2,842 Bytes
1e92f2d |
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 |
package alertlog
import (
"context"
"database/sql"
"text/template"
"github.com/target/goalert/permission"
"github.com/target/goalert/search"
"github.com/target/goalert/util/sqlutil"
"github.com/target/goalert/validation/validate"
"github.com/pkg/errors"
)
// SearchOptions contains criteria for filtering alert logs.
type SearchOptions struct {
// FilterAlertIDs restricts the log entries belonging to specific alertIDs only.
FilterAlertIDs []int `json:"f"`
// Limit restricts the maximum number of rows returned. Default is 15.
Limit int `json:"-"`
After SearchCursor `json:"a,omitempty"`
}
type SearchCursor struct {
ID int `json:"i,omitempty"`
}
var searchTemplate = template.Must(template.New("search").Parse(`
SELECT
log.id,
log.alert_id,
log.timestamp,
log.event,
log.message,
log.sub_type,
log.sub_user_id,
u.name,
log.sub_integration_key_id,
i.name,
log.sub_hb_monitor_id,
hb.name,
log.sub_channel_id,
nc.name,
log.sub_classifier,
log.meta
FROM alert_logs log
LEFT JOIN users u ON u.id = log.sub_user_id
LEFT JOIN integration_keys i ON i.id = log.sub_integration_key_id
LEFT JOIN heartbeat_monitors hb ON hb.id = log.sub_hb_monitor_id
LEFT JOIN notification_channels nc ON nc.id = log.sub_channel_id
WHERE TRUE
{{- if .FilterAlertIDs}}
AND log.alert_id = ANY(:alertIDs)
{{- end}}
{{- if .After.ID}}
AND (log.id < :afterID)
{{- end}}
ORDER BY log.id DESC
LIMIT {{.Limit}}
`))
type renderData SearchOptions
func (opts renderData) Normalize() (*renderData, error) {
if opts.Limit == 0 {
opts.Limit = search.DefaultMaxResults
}
err := validate.Many(
validate.Range("FilterAlertIDs", len(opts.FilterAlertIDs), 0, 50),
validate.Range("Limit", opts.Limit, 0, search.MaxResults),
)
if err != nil {
return nil, err
}
return &opts, nil
}
func (opts renderData) QueryArgs() []sql.NamedArg {
return []sql.NamedArg{
sql.Named("afterID", opts.After.ID),
sql.Named("alertIDs", sqlutil.IntArray(opts.FilterAlertIDs)),
}
}
// Search will return a list of matching log entries
func (s *Store) Search(ctx context.Context, opts *SearchOptions) ([]Entry, error) {
if opts == nil {
opts = &SearchOptions{}
}
err := permission.LimitCheckAny(ctx, permission.System, permission.Admin, permission.User)
if err != nil {
return nil, err
}
data, err := (*renderData)(opts).Normalize()
if err != nil {
return nil, err
}
query, args, err := search.RenderQuery(ctx, searchTemplate, data)
if err != nil {
return nil, errors.Wrap(err, "render query")
}
rows, err := s.db.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var result []Entry
for rows.Next() {
var r Entry
err = r.scanWith(rows.Scan)
if err != nil {
return nil, err
}
result = append(result, r)
}
return result, nil
}
|