Method runSequence

pkg/rules/sequence.go:439–555

(e *event.Event)

}

func (s *sequenceState) runSequence(e *event.Event) bool {
	for i, expr := range s.seq.Expressions {
		// only try to evaluate the expression
		// if upstream expressions have matched
		if !s.next(i) {
			if !s.seq.IsUnordered {
				continue
			}
			// it could be the event arrived out
			// of order because certain provider
			// flushed its buffers first. When this
			// happens the event timestamp serves as
			// a temporal reference.
			// If this sequence expression can evaluate
			// against the current event, mark it as
			// out-of-order and store in partials list
			s.mu.RLock()
			ok := expr.IsEvaluable(e) && s.filter.RunSequence(e, i, s.partials, true)
			s.mu.RUnlock()
			if ok {
				s.addPartial(i, e, true)
			}
			continue
		}

		s.mu.RLock()
		matches := expr.IsEvaluable(e) && s.filter.RunSequence(e, i, s.partials, false)
		s.mu.RUnlock()

		if !matches {
			continue
		}

		// enforce temporal monotonicity check for ordered sequences
		if !s.seq.IsUnordered && !s.lastMatch.IsZero() && !e.Timestamp.After(s.lastMatch) {
			// this event is older than or equal to the previous matched slot
			continue
		}

		// append the partial and transition state machine
		s.addPartial(i, e, false)
		err := s.matchTransition(i, e)
		if err != nil {
			matchTransitionErrors.Add(1)
			log.Warnf("match transition failure: %v", err)
		}
		if !s.seq.IsUnordered {
			s.lastMatch = e.Timestamp
		}
		// now try to match all pending out-of-order
		// events from downstream sequence slots if
		// the previous match hasn't reached terminal
		// state
		if s.seq.IsUnordered && s.currentState() != sequenceTerminalState {
			s.mu.RLock()
			for seqID := range s.partials {
				for _, evt := range s.partials[seqID] {
					if !evt.ContainsMeta(event.RuleSequenceOOOKey) {