101 lines
2.2 KiB
Go
101 lines
2.2 KiB
Go
// Package alert define alert event struct of modelRT project
|
|
package alert
|
|
|
|
import (
|
|
"sort"
|
|
"sync"
|
|
|
|
constants "modelRT/constant"
|
|
)
|
|
|
|
var (
|
|
once sync.Once
|
|
_globalManagerMu sync.RWMutex
|
|
_globalManager *EventManager
|
|
)
|
|
|
|
// Event define alert event struct
|
|
type Event struct {
|
|
ComponentID int64
|
|
AnchorName string
|
|
Level constants.AlertLevel
|
|
Message string
|
|
StartTime int64
|
|
}
|
|
|
|
// EventManager define store and manager alert event struct
|
|
type EventManager struct {
|
|
mu sync.RWMutex
|
|
events map[constants.AlertLevel][]Event
|
|
}
|
|
|
|
// EventSet define alert event set implement sort.Interface
|
|
type EventSet []Event
|
|
|
|
func (es EventSet) Len() int {
|
|
return len(es)
|
|
}
|
|
|
|
func (es EventSet) Less(i, j int) bool {
|
|
return es[i].StartTime < es[j].StartTime
|
|
}
|
|
|
|
func (es EventSet) Swap(i, j int) {
|
|
es[i], es[j] = es[j], es[i]
|
|
}
|
|
|
|
// AddEvent define add a alert event to event manager
|
|
func (am *EventManager) AddEvent(event Event) {
|
|
am.mu.Lock()
|
|
defer am.mu.Unlock()
|
|
|
|
am.events[event.Level] = append(am.events[event.Level], event)
|
|
}
|
|
|
|
// GetEventsByLevel define get alert event by alert level
|
|
func (am *EventManager) GetEventsByLevel(level constants.AlertLevel) []Event {
|
|
am.mu.Lock()
|
|
defer am.mu.Unlock()
|
|
|
|
return am.events[level]
|
|
}
|
|
|
|
// GetRangeEventsByLevel define get range alert event by alert level
|
|
func (am *EventManager) GetRangeEventsByLevel(targetLevel constants.AlertLevel) []Event {
|
|
var targetEvents []Event
|
|
|
|
am.mu.Lock()
|
|
defer am.mu.Unlock()
|
|
|
|
for level, events := range am.events {
|
|
if targetLevel <= level {
|
|
targetEvents = append(targetEvents, events...)
|
|
}
|
|
}
|
|
sort.Sort(EventSet(targetEvents))
|
|
return targetEvents
|
|
}
|
|
|
|
// InitAlertEventManager define new alert event manager
|
|
func InitAlertEventManager() *EventManager {
|
|
return &EventManager{
|
|
events: make(map[constants.AlertLevel][]Event),
|
|
}
|
|
}
|
|
|
|
// InitAlertManagerInstance return instance of zap logger
|
|
func InitAlertManagerInstance() *EventManager {
|
|
once.Do(func() {
|
|
_globalManager = InitAlertEventManager()
|
|
})
|
|
return _globalManager
|
|
}
|
|
|
|
// GetAlertMangerInstance returns the global alert manager instance It's safe for concurrent use.
|
|
func GetAlertMangerInstance() *EventManager {
|
|
_globalManagerMu.RLock()
|
|
manager := _globalManager
|
|
_globalManagerMu.RUnlock()
|
|
return manager
|
|
}
|