parse datacenter from Tags field

config.go

@@ -26,6 +26,7 @@ type Config struct {
 	LocalCheckpoint   string
 	LocalTokenizer    string
 	AssetPattern      string
+	DatacenterPattern string
 	storage           Storage
 	queue             Queue
 	driver            Driver
@@ -41,6 +42,7 @@ func newConfigFromEnv(ctx context.Context, getEnv func(string) string) (Config,
 		Port:              38080,
 		OllamaModel:       "gemma:2b",
 		AssetPattern:      `(dpg|svc|red)-[a-z0-9-]*`,
+		DatacenterPattern: `[a-z]{4}[a-z]*-[0-9]`,
 	}
 
 	var m map[string]any
@@ -105,7 +107,7 @@ func newConfigFromEnv(ctx context.Context, getEnv func(string) string) (Config,
 		result.driver = pg
 	}
 	if result.FillWithTestdata {
-		if err := FillWithTestdata(ctx, result.driver, result.AssetPattern); err != nil {
+		if err := FillWithTestdata(ctx, result.driver, result.AssetPattern, result.DatacenterPattern); err != nil {
 			return Config{}, err
 		}
 	}

driver.go

@@ -23,7 +23,7 @@ type Driver interface {
 	Set(context.Context, string, string, []byte) error
 }
 
-func FillWithTestdata(ctx context.Context, driver Driver, assetPattern string) error {
+func FillWithTestdata(ctx context.Context, driver Driver, assetPattern, datacenterPattern string) error {
 	d := "./testdata/slack_events"
 	entries, err := os.ReadDir(d)
 	if err != nil {
@@ -37,7 +37,7 @@ func FillWithTestdata(ctx context.Context, driver Driver, assetPattern string) e
 		if err != nil {
 			return err
 		}
-		m, err := ParseSlack(b, assetPattern)
+		m, err := ParseSlack(b, assetPattern, datacenterPattern)
 		if errors.Is(err, ErrIrrelevantMessage) {
 			continue
 		} else if err != nil {

driver_test.go

@@ -17,7 +17,7 @@ func TestFillTestdata(t *testing.T) {
 	defer can()
 
 	ram := NewRAM()
-	if err := FillWithTestdata(ctx, ram, renderAssetPattern); err != nil {
+	if err := FillWithTestdata(ctx, ram, renderAssetPattern, renderDatacenterPattern); err != nil {
 		t.Fatal(err)
 	}
 	n := 0

main.go

@@ -65,6 +65,8 @@ func newHandler(cfg Config) http.HandlerFunc {
 	mux := http.NewServeMux()
 
 	mux.Handle("POST /api/v1/events/slack", http.HandlerFunc(newHandlerPostAPIV1EventsSlack(cfg)))
+	mux.Handle("GET /api/v1/eventnames", http.HandlerFunc(newHandlerGetAPIV1EventNames(cfg)))
+	mux.Handle("GET /api/v1/events", http.HandlerFunc(newHandlerGetAPIV1Events(cfg)))
 	mux.Handle("GET /api/v1/messages", http.HandlerFunc(newHandlerGetAPIV1Messages(cfg)))
 	mux.Handle("GET /api/v1/threads", http.HandlerFunc(newHandlerGetAPIV1Threads(cfg)))
 	mux.Handle("GET /api/v1/threads/{thread}", http.HandlerFunc(newHandlerGetAPIV1ThreadsThread(cfg)))
@@ -80,6 +82,50 @@ func newHandler(cfg Config) http.HandlerFunc {
 	}
 }
 
+func newHandlerGetAPIV1EventNames(cfg Config) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if !basicAuth(cfg, w, r) {
+			return
+		}
+
+		since, err := parseSince(r.URL.Query().Get("since"))
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		eventNames, err := cfg.storage.EventNamesSince(r.Context(), since)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		encodeResponse(w, r, map[string]any{"eventNames": eventNames})
+	}
+}
+
+func newHandlerGetAPIV1Events(cfg Config) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if !basicAuth(cfg, w, r) {
+			return
+		}
+
+		since, err := parseSince(r.URL.Query().Get("since"))
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		events, err := cfg.storage.EventsSince(r.Context(), since)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		encodeResponse(w, r, map[string]any{"events": events})
+	}
+}
+
 func newHandlerGetAPIV1Messages(cfg Config) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		if !basicAuth(cfg, w, r) {
@@ -200,7 +246,7 @@ func _newHandlerPostAPIV1EventsSlack(cfg Config) http.HandlerFunc {
 			return
 		}
 
-		m, err := ParseSlack(b, cfg.AssetPattern)
+		m, err := ParseSlack(b, cfg.AssetPattern, cfg.DatacenterPattern)
 		if errors.Is(err, ErrIrrelevantMessage) {
 			return
 		} else if err != nil {

main_test.go

@@ -104,6 +104,52 @@ func TestRun(t *testing.T) {
 		}
 	})
 
+	t.Run("GET /api/v1/eventnames", func(t *testing.T) {
+		resp, err := http.Get(fmt.Sprintf("%s/api/v1/eventnames", u))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			b, _ := io.ReadAll(resp.Body)
+			t.Fatalf("(%d) %s", resp.StatusCode, b)
+		}
+		var result struct {
+			EventNames []string
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			t.Fatal(err)
+		} else if result.EventNames[0] != "[Oregon-1] Wal Receive Count Alert" {
+			t.Fatal(result.EventNames)
+		} else {
+			t.Logf("%+v", result)
+		}
+	})
+
+	t.Run("GET /api/v1/events", func(t *testing.T) {
+		resp, err := http.Get(fmt.Sprintf("%s/api/v1/events", u))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			b, _ := io.ReadAll(resp.Body)
+			t.Fatalf("(%d) %s", resp.StatusCode, b)
+		}
+		var result struct {
+			Events []string
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			t.Fatal(err)
+		} else if result.Events[0] != "11067" {
+			t.Fatal(result.Events)
+		} else {
+			t.Logf("%+v", result)
+		}
+	})
+
 	t.Run("GET /api/v1/threads", func(t *testing.T) {
 		resp, err := http.Get(fmt.Sprintf("%s/api/v1/threads", u))
 		if err != nil {

message.go

@@ -24,6 +24,7 @@ type Message struct {
 	Plaintext  string
 	Asset      string
 	Resolved   bool
+	Datacenter string
 }
 
 func (m Message) Empty() bool {
@@ -106,8 +107,9 @@ type (
 	slackAction struct{}
 )
 
-func ParseSlack(b []byte, assetPattern string) (Message, error) {
+func ParseSlack(b []byte, assetPattern, datacenterPattern string) (Message, error) {
 	asset := regexp.MustCompile(assetPattern)
+	datacenter := regexp.MustCompile(datacenterPattern)
 
 	s, err := parseSlack(b)
 	if err != nil {
@@ -120,6 +122,12 @@ func ParseSlack(b []byte, assetPattern string) (Message, error) {
 		} else if !strings.Contains(s.Event.Attachments[0].Title, ": Firing: ") {
 			return Message{}, ErrIrrelevantMessage
 		}
+		var tagsField string
+		for _, field := range s.Event.Attachments[0].Fields {
+			if field.Title == "Tags" {
+				tagsField = field.Value
+			}
+		}
 		return Message{
 			ID:         fmt.Sprintf("%s/%v", s.Event.ID, s.TS),
 			TS:         s.TS,
@@ -131,6 +139,7 @@ func ParseSlack(b []byte, assetPattern string) (Message, error) {
 			Plaintext:  s.Event.Attachments[0].Text,
 			Asset:      asset.FindString(s.Event.Attachments[0].Text),
 			Resolved:   !strings.HasPrefix(s.Event.Attachments[0].Color, "F"),
+			Datacenter: datacenter.FindString(tagsField),
 		}, nil
 	}
 
@@ -147,6 +156,7 @@ func ParseSlack(b []byte, assetPattern string) (Message, error) {
 		Event:      "",
 		Plaintext:  s.Event.Text,
 		Asset:      asset.FindString(s.Event.Text),
+		Datacenter: datacenter.FindString(s.Event.Text),
 	}, nil
 }
 

message_test.go

@@ -9,6 +9,7 @@ import (
 
 var (
 	renderAssetPattern      = `(dpg|svc|red)-[a-z0-9-]*[a-z0-9]`
+	renderDatacenterPattern = `[a-z]{4}[a-z]*-[0-9]`
 )
 
 func TestParseSlackTestdata(t *testing.T) {
@@ -139,7 +140,7 @@ func TestParseSlackTestdata(t *testing.T) {
 			})
 
 			t.Run("ParseSlack", func(t *testing.T) {
-				got, err := ParseSlack(b, renderAssetPattern)
+				got, err := ParseSlack(b, renderAssetPattern, renderDatacenterPattern)
 				if err != nil {
 					t.Fatal(err)
 				}

storage.go

@@ -25,6 +25,40 @@ func (s Storage) MessagesSince(ctx context.Context, t time.Time) ([]Message, err
 	})
 }
 
+func (s Storage) EventNamesSince(ctx context.Context, t time.Time) ([]string, error) {
+	messages, err := s.MessagesSince(ctx, t)
+	if err != nil {
+		return nil, err
+	}
+	names := map[string]struct{}{}
+	for _, m := range messages {
+		names[m.EventName] = struct{}{}
+	}
+	result := make([]string, 0, len(names))
+	for k := range names {
+		result = append(result, k)
+	}
+	sort.Strings(result)
+	return result, nil
+}
+
+func (s Storage) EventsSince(ctx context.Context, t time.Time) ([]string, error) {
+	messages, err := s.MessagesSince(ctx, t)
+	if err != nil {
+		return nil, err
+	}
+	events := map[string]struct{}{}
+	for _, m := range messages {
+		events[m.Event] = struct{}{}
+	}
+	result := make([]string, 0, len(events))
+	for k := range events {
+		result = append(result, k)
+	}
+	sort.Strings(result)
+	return result, nil
+}
+
 func (s Storage) Threads(ctx context.Context) ([]string, error) {
 	return s.ThreadsSince(ctx, time.Unix(0, 0))
 }