nflog: use alert set instead of hash for deduplication

Building a hash over an entire set of alerts causes problems, because
the hash differs, on any change, whereas we only want to send
notifications if the alert and it's state have changed. Therefore this
introduces a list of alerts that are active and a list of alerts that
are resolved. If the currently active alerts of a group are a subset of
the ones that have been notified about before then they are
deduplicated. The resolved notifications work the same way, with a
separate list of resolved notifications that have already been sent.

Makefile

@@ -66,5 +66,7 @@ promu:
 	GOARCH=$(subst x86_64,amd64,$(patsubst i%86,386,$(shell uname -m))) \
 	$(GO) get -u github.com/prometheus/promu
 
+proto:
+	scripts/genproto.sh
 
-.PHONY: all style format build test vet assets tarball docker promu
+.PHONY: all style format build test vet assets tarball docker promu proto

nflog/nflog.go

@@ -44,8 +44,7 @@ type Log interface {
 	// The Log* methods store a notification log entry for
 	// a fully qualified receiver and a given IDs identifying the
 	// alert object.
-	LogActive(r *pb.Receiver, key, hash []byte) error
-	LogResolved(r *pb.Receiver, key, hash []byte) error
+	Log(r *pb.Receiver, key []byte, firing, resolved []uint64) error
 
 	// Query the log along the given Paramteres.
 	//
@@ -325,23 +324,13 @@ Loop:
 	}
 }
 
-// LogActive implements the Log interface.
-func (l *nlog) LogActive(r *pb.Receiver, key, hash []byte) error {
-	return l.log(r, key, hash, false)
-}
-
-// LogResolved implements the Log interface.
-func (l *nlog) LogResolved(r *pb.Receiver, key, hash []byte) error {
-	return l.log(r, key, hash, true)
-}
-
 // stateKey returns a string key for a log entry consisting of the group key
 // and receiver.
 func stateKey(k []byte, r *pb.Receiver) string {
 	return fmt.Sprintf("%s:%s", k, r)
 }
 
-func (l *nlog) log(r *pb.Receiver, gkey, ghash []byte, resolved bool) error {
+func (l *nlog) Log(r *pb.Receiver, gkey []byte, firingAlerts, resolvedAlerts []uint64) error {
 	// Write all st with the same timestamp.
 	now := l.now()
 	key := stateKey(gkey, r)
@@ -372,11 +361,11 @@ func (l *nlog) log(r *pb.Receiver, gkey, ghash []byte, resolved bool) error {
 
 	e := &pb.MeshEntry{
 		Entry: &pb.Entry{
-			Receiver:  r,
-			GroupKey:  gkey,
-			GroupHash: ghash,
-			Resolved:  resolved,
-			Timestamp: ts,
+			Receiver:       r,
+			GroupKey:       gkey,
+			Timestamp:      ts,
+			FiringAlerts:   firingAlerts,
+			ResolvedAlerts: resolvedAlerts,
 		},
 		ExpiresAt: expts,
 	}

nflog/nflogpb/nflog.proto

@@ -22,11 +22,17 @@ message Entry {
   // The receiver that was notified.
   Receiver receiver = 2;
   // Hash over the state of the group at notification time.
+  // Deprecated in favor of FiringAlerts field, but kept for compatibility.
   bytes group_hash = 3;
   // Whether the notification was about a resolved alert.
+  // Deprecated in favor of ResolvedAlerts field, but kept for compatibility.
   bool resolved = 4;
   // Timestamp of the succeeding notification.
   google.protobuf.Timestamp timestamp = 5;
+  // FiringAlerts list of hashes of firing alerts at last notification.
+  repeated uint64 firing_alerts = 6;
+  // ResolvedAlerts list hashes of resolved alerts at last notification.
+  repeated uint64 resolved_alerts = 7;
 }
 
 // MeshEntry is a wrapper message to communicate a notify log

nflog/nflogpb/set.go

@@ -0,0 +1,30 @@
+package nflogpb
+
+func (m *Entry) IsFiringSubset(subset map[uint64]struct{}) bool {
+	set := map[uint64]struct{}{}
+	for i := range m.FiringAlerts {
+		set[m.FiringAlerts[i]] = struct{}{}
+	}
+
+	return isSubset(set, subset)
+}
+
+func (m *Entry) IsResolvedSubset(subset map[uint64]struct{}) bool {
+	set := map[uint64]struct{}{}
+	for i := range m.ResolvedAlerts {
+		set[m.ResolvedAlerts[i]] = struct{}{}
+	}
+
+	return isSubset(set, subset)
+}
+
+func isSubset(set, subset map[uint64]struct{}) bool {
+	for k, _ := range subset {
+		_, exists := set[k]
+		if !exists {
+			return false
+		}
+	}
+
+	return true
+}