amigan/stillbox
1
0
Fork 0
Code Issues 16 Pull requests Projects Releases Packages Wiki Activity Actions

Refactor alertrules so they unmarshal by pgx #32

Merged
amigan merged 1 commit from reid into trunk 2024-11-12 08:42:36 -05:00
Conversation 0 Commits 1 Files changed 10 +95 -79
10 changed files with 95 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
pkg/alerting/rules/alertrules.go Normal file
View file

@ -0,0 +1,36 @@
package rules
import (
"time"
"dynatron.me/x/stillbox/internal/ruletime"
)
type AlertRules []AlertRule
func (ars *AlertRules) Apply(t time.Time, coversOpts ...ruletime.CoversOption) float64 {
final := 1.0
for _, ar := range *ars {
if ar.MatchTime(t, coversOpts...) {
final *= float64(ar.ScoreMultiplier)
}
}
return final
}
type AlertRule struct {
Times []ruletime.RuleTime `json:"times"`
ScoreMultiplier float32 `json:"mult"`
}
func (ar *AlertRule) MatchTime(t time.Time, coversOpts ...ruletime.CoversOption) bool {
for _, at := range ar.Times {
if at.Covers(t, coversOpts...) {
return true
}
}
return false
}

12
pkg/talkgroups/alertconfig_test.go → pkg/alerting/rules/alertrules_test.go
View file

@ -1,6 +1,7 @@
package talkgroups_test
package rules_test
import (
"encoding/json"
"errors"
"math"
"testing"
@ -8,6 +9,7 @@ import (
"dynatron.me/x/stillbox/internal/ruletime"
"dynatron.me/x/stillbox/internal/trending"
"dynatron.me/x/stillbox/pkg/alerting/rules"
"dynatron.me/x/stillbox/pkg/talkgroups"
"github.com/stretchr/testify/assert"
@ -20,14 +22,14 @@ func TestAlertConfig(t *testing.T) {
name string
tg talkgroups.ID
conf string
compare []talkgroups.AlertRule
compare rules.AlertRules
expectErr error
}{
{
name: "base case",
tg: talkgroups.TG(197, 3),
conf: `[{"times":["7:00+2h","01:00+1h","16:00+1h","19:00+4h"],"mult":0.2},{"times":["11:00+1h","15:00+30m","16:03+20m"],"mult":2.0}]`,
compare: []talkgroups.AlertRule{
compare: rules.AlertRules{
{
Times: []ruletime.RuleTime{
ruletime.Must(ruletime.New("7:00+2h")),
@ -57,11 +59,13 @@ func TestAlertConfig(t *testing.T) {
for _, tc := range parseTests {
t.Run(tc.name, func(t *testing.T) {
err := ac.UnmarshalTGRules(tc.tg, []byte(tc.conf))
var ar rules.AlertRules
err := json.Unmarshal([]byte(tc.conf), &ar)
if tc.expectErr != nil {
require.Error(t, err)
assert.Contains(t, err.Error(), tc.expectErr.Error())
} else {
ac.Add(tc.tg, ar)
assert.Equal(t, tc.compare, ac.GetRules(tc.tg))
}
})

3
pkg/database/models.go
View file

@ -7,6 +7,7 @@ package database
import (
"time"
"dynatron.me/x/stillbox/pkg/alerting/rules"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgtype"
)
@ -92,7 +93,7 @@ type Talkgroup struct {
Metadata []byte `json:"metadata"`
Tags []string `json:"tags"`
Alert bool `json:"alert"`
AlertConfig []byte `json:"alert_config"`
AlertConfig rules.AlertRules `json:"alert_config"`
Weight float32 `json:"weight"`
}

4
pkg/database/talkgroups.sql.go
View file

@ -7,6 +7,8 @@ package database
import (
"context"
"dynatron.me/x/stillbox/pkg/alerting/rules"
)
const bulkSetTalkgroupTags = `-- name: BulkSetTalkgroupTags :exec
@ -497,7 +499,7 @@ type UpdateTalkgroupParams struct {
Metadata []byte `json:"metadata"`
Tags []string `json:"tags"`
Alert *bool `json:"alert"`
AlertConfig []byte `json:"alert_config"`
AlertConfig rules.AlertRules `json:"alert_config"`
Weight *float32 `json:"weight"`
ID int64 `json:"id"`
}

6
pkg/database/talkgroups.sql_test.go
View file

@ -6,7 +6,7 @@ import (
"github.com/stretchr/testify/require"
)
const getTalkgroupWithLearnedByPackedIDsTest = `-- name: GetTalkgroupWithLearnedByPackedIDs :many
const getTalkgroupsWithLearnedByPackedIDsTest = `-- name: GetTalkgroupsWithLearnedByPackedIDs :many
SELECT
tg.id, tg.system_id, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.weight, sys.id, sys.name,
FALSE learned
@ -59,7 +59,7 @@ TRUE, NULL::JSONB, 1.0, sys.id, sys.name,
TRUE learned
FROM talkgroups_learned tgl
JOIN systems sys ON tgl.system_id = sys.id
WHERE tg.system_id = $1 AND ignored IS NOT TRUE
WHERE tgl.system_id = $1 AND ignored IS NOT TRUE
`
const getTalkgroupsWithLearnedTest = `-- name: GetTalkgroupsWithLearned :many
@ -81,7 +81,7 @@ WHERE ignored IS NOT TRUE
`
func TestQueryColumnsMatch(t *testing.T) {
require.Equal(t, getTalkgroupsWithLearnedByPackedIDsTest, getTalkgroupWithLearnedByPackedIDs)
require.Equal(t, getTalkgroupsWithLearnedByPackedIDsTest, getTalkgroupsWithLearnedByPackedIDs)
require.Equal(t, getTalkgroupWithLearnedTest, getTalkgroupWithLearned)
require.Equal(t, getTalkgroupsWithLearnedBySystemTest, getTalkgroupsWithLearnedBySystem)
require.Equal(t, getTalkgroupsWithLearnedTest, getTalkgroupsWithLearned)

1
pkg/rest/api.go
View file

@ -43,7 +43,6 @@ type errResponse struct {
func (e *errResponse) Render(w http.ResponseWriter, r *http.Request) error {
switch e.Code {
case http.StatusNotFound:
case http.StatusBadRequest:
default:
log.Error().Str("path", r.URL.Path).Err(e.Err).Int("code", e.Code).Str("msg", e.Error).Msg("request failed")
}

59
pkg/talkgroups/alertconfig.go
View file

@ -1,54 +1,39 @@
package talkgroups
import (
"encoding/json"
"sync"
"time"
"dynatron.me/x/stillbox/internal/ruletime"
"dynatron.me/x/stillbox/pkg/alerting/rules"
)
type AlertConfig struct {
sync.RWMutex
m map[ID][]AlertRule
}
type AlertRule struct {
Times []ruletime.RuleTime `json:"times"`
ScoreMultiplier float32 `json:"mult"`
m map[ID]rules.AlertRules
}
func NewAlertConfig() AlertConfig {
return AlertConfig{
m: make(map[ID][]AlertRule),
m: make(map[ID]rules.AlertRules),
}
}
func (ac *AlertConfig) GetRules(tg ID) []AlertRule {
func (ac *AlertConfig) Add(tg ID, r rules.AlertRules) error {
ac.Lock()
defer ac.Unlock()
ac.m[tg] = r
return nil
}
func (ac *AlertConfig) GetRules(tg ID) rules.AlertRules {
ac.RLock()
defer ac.RUnlock()
return ac.m[tg]
}
func (ac *AlertConfig) UnmarshalTGRules(tg ID, confBytes []byte) error {
ac.Lock()
defer ac.Unlock()
if len(confBytes) == 0 {
return nil
}
var rules []AlertRule
err := json.Unmarshal(confBytes, &rules)
if err != nil {
return err
}
ac.m[tg] = rules
return nil
}
func (ac *AlertConfig) ApplyAlertRules(id ID, t time.Time, coversOpts ...ruletime.CoversOption) float64 {
ac.RLock()
s, has := ac.m[id]
@ -57,15 +42,7 @@ func (ac *AlertConfig) ApplyAlertRules(id ID, t time.Time, coversOpts ...ruletim
return 1.0
}
final := 1.0
for _, ar := range s {
if ar.MatchTime(t, coversOpts...) {
final *= float64(ar.ScoreMultiplier)
}
}
return final
return s.Apply(t, coversOpts...)
}
func (ac *AlertConfig) Invalidate() {
@ -74,13 +51,3 @@ func (ac *AlertConfig) Invalidate() {
clear(ac.m)
}
func (ar *AlertRule) MatchTime(t time.Time, coversOpts ...ruletime.CoversOption) bool {
for _, at := range ar.Times {
if at.Covers(t, coversOpts...) {
return true
}
}
return false
}

4
pkg/talkgroups/cache.go
View file

@ -139,7 +139,9 @@ func (t *cache) add(rec *Talkgroup) error {
t.tgs[tg] = rec
t.systems[int32(rec.System.ID)] = rec.System.Name
return t.AlertConfig.UnmarshalTGRules(tg, rec.Talkgroup.AlertConfig)
t.AlertConfig.Add(tg, rec.AlertConfig)
return nil
}
type row interface {

5
sql/sqlc.yaml
View file

@ -27,3 +27,8 @@ sql:
go_type: "time.Time"
- db_type: "pg_catalog.text"
go_type: "string"
- column: "talkgroups.alert_config"
go_type:
import: "dynatron.me/x/stillbox/pkg/alerting/rules"
type: "AlertRules"
nullable: true