diff --git a/config/config.go b/config/config.go index 4c13e2a5..289ed0cd 100644 --- a/config/config.go +++ b/config/config.go @@ -271,8 +271,8 @@ func (d *Config) init() { d.vars.Register(value.NewInt(&d.Sessions.SessionTimeout, 30), "sessions.session_timeout_sec", "CORE_SESSIONS_SESSION_TIMEOUT_SEC", nil, "Timeout for an idle session", false, false) d.vars.Register(value.NewStrftime(&d.Sessions.SessionLogPathPattern, ""), "sessions.session_log_path_pattern", "CORE_SESSIONS_SESSION_LOG_PATH_PATTERN", nil, "Path to where the sessions will be logged, may contain strftime-patterns, leave empty for no session logging, persist must be enabled", false, false) d.vars.Register(value.NewInt(&d.Sessions.SessionLogBuffer, 15), "sessions.session_log_buffer_sec", "CORE_SESSIONS_SESSION_LOG_BUFFER_SEC", nil, "Maximum duration to buffer session logs in memory before persisting on disk", false, false) - d.vars.Register(value.NewBool(&d.Sessions.Persist, false), "sessions.persist", "CORE_SESSIONS_PERSIST", nil, "Whether to persist session history. Will be stored in /sessions/[collector].json in db.dir", false, false) - d.vars.Register(value.NewInt(&d.Sessions.PersistInterval, 300), "sessions.persist_interval_sec", "CORE_SESSIONS_PERSIST_INTERVAL_SEC", nil, "Interval in seconds in which to persist the current session history", false, false) + d.vars.Register(value.NewBool(&d.Sessions.Persist, false), "sessions.persist", "CORE_SESSIONS_PERSIST", nil, "Whether to persist session history or logs. Will be stored in /sessions in db.dir", false, false) + d.vars.Register(value.NewInt(&d.Sessions.PersistInterval, 300), "sessions.persist_interval_sec", "CORE_SESSIONS_PERSIST_INTERVAL_SEC", nil, "Interval in seconds in which to persist the current session history, 0 only on shutdown, negative never", false, false) d.vars.Register(value.NewUint64(&d.Sessions.MaxBitrate, 0), "sessions.max_bitrate_mbit", "CORE_SESSIONS_MAXBITRATE_MBIT", nil, "Max. allowed outgoing bitrate in mbit/s, 0 for unlimited", false, false) d.vars.Register(value.NewUint64(&d.Sessions.MaxSessions, 0), "sessions.max_sessions", "CORE_SESSIONS_MAX_SESSIONS", []string{"CORE_SESSIONS_MAXSESSIONS"}, "Max. allowed number of simultaneous sessions, 0 for unlimited", false, false) @@ -448,11 +448,6 @@ func (d *Config) Validate(resetLogs bool) { d.vars.Log("error", "stats.session_timeout_sec", "must be equal or greater than 1") } - // If the stats and their persistence are enabled, the persist interval has to be set to a useful value - if d.Sessions.Enable && d.Sessions.PersistInterval < 0 { - d.vars.Log("error", "stats.persist_interval_sec", "must be at equal or greater than 0") - } - // If the service is enabled, the token and enpoint have to be defined if d.Service.Enable { if len(d.Service.Token) == 0 { diff --git a/session/collector.go b/session/collector.go index 729355dd..bba85e98 100644 --- a/session/collector.go +++ b/session/collector.go @@ -242,7 +242,8 @@ type collector struct { rxBitrate *average.SlidingWindow txBitrate *average.SlidingWindow - history history + collectHistory bool + history history inactiveTimeout time.Duration sessionTimeout time.Duration @@ -269,7 +270,7 @@ const ( // NewCollector returns a new collector according to the provided configuration. If such a // collector can't be created, a NullCollector is returned. func NewCollector(config CollectorConfig) Collector { - collector, err := newCollector("", nil, nil, config) + collector, err := newCollector("", nil, nil, false, config) if err != nil { return NewNullCollector() } @@ -279,7 +280,7 @@ func NewCollector(config CollectorConfig) Collector { return collector } -func newCollector(id string, sessionsCh chan<- Session, logger log.Logger, config CollectorConfig) (*collector, error) { +func newCollector(id string, sessionsCh chan<- Session, logger log.Logger, history bool, config CollectorConfig) (*collector, error) { c := &collector{ id: id, logger: logger, @@ -290,6 +291,7 @@ func newCollector(id string, sessionsCh chan<- Session, logger log.Logger, confi inactiveTimeout: config.InactiveTimeout, sessionTimeout: config.SessionTimeout, limiter: config.Limiter, + collectHistory: history, } if c.logger == nil { @@ -347,26 +349,28 @@ func newCollector(id string, sessionsCh chan<- Session, logger log.Logger, confi // Only log session that have been active logger.Info().Log("Closed") - c.lock.history.Lock() + if c.collectHistory { + c.lock.history.Lock() - key := sess.location + ":" + sess.peer + ":" + sess.reference + key := sess.location + ":" + sess.peer + ":" + sess.reference - // Update history totals per key - t, ok := c.history.Sessions[key] - t.TotalSessions++ - t.TotalRxBytes += sess.rxBytes - t.TotalTxBytes += sess.txBytes + // Update history totals per key + t, ok := c.history.Sessions[key] + t.TotalSessions++ + t.TotalRxBytes += sess.rxBytes + t.TotalTxBytes += sess.txBytes - if !ok { - t.Location = sess.location - t.Peer = sess.peer - t.Reference = sess.reference + if !ok { + t.Location = sess.location + t.Peer = sess.peer + t.Reference = sess.reference + } + + c.history.Sessions[key] = t + + c.lock.history.Unlock() } - c.history.Sessions[key] = t - - c.lock.history.Unlock() - if c.sessionsCh != nil { c.sessionsCh <- Session{ Collector: c.id, @@ -458,6 +462,11 @@ func (s *historySnapshot) Release() { func (c *collector) Snapshot() (Snapshot, error) { c.logger.Debug().Log("Creating history snapshot") + if !c.collectHistory { + c.logger.Debug().Log("Not creating history snapshot because collector history is disabled") + return nil, fmt.Errorf("collecting history is disabled") + } + c.lock.history.Lock() defer c.lock.history.Unlock() @@ -478,6 +487,11 @@ func (c *collector) Restore(snapshot io.ReadCloser) error { return nil } + if !c.collectHistory { + c.logger.Debug().Log("Not restoring history snapshot because collector history is disabled") + return nil + } + defer snapshot.Close() c.logger.Debug().Log("Restoring history snapshot") diff --git a/session/collector_test.go b/session/collector_test.go index a9959835..b29a513b 100644 --- a/session/collector_test.go +++ b/session/collector_test.go @@ -9,7 +9,7 @@ import ( ) func createCollector(inactive, session time.Duration, sessionsCh chan<- Session) (*collector, error) { - return newCollector("test", sessionsCh, nil, CollectorConfig{ + return newCollector("test", sessionsCh, nil, true, CollectorConfig{ InactiveTimeout: inactive, SessionTimeout: session, }) diff --git a/session/registry.go b/session/registry.go index 03353e07..8970aeb0 100644 --- a/session/registry.go +++ b/session/registry.go @@ -21,12 +21,12 @@ type Config struct { // history will not be persisted. PersistFS fs.Filesystem - // PersistInterval is the duration between persisting the history. Can be 0. Then the history will - // only be persisted at stopping the collector. + // PersistInterval is the duration between persisting the history. If 0 the history will + // only be persisted at stopping the collector. If negative, the history will not be persisted. PersistInterval time.Duration // SessionLogPattern is a path inside the PersistFS where the individual sessions will - // be logged. The path can contain strftime-plateholders in order to split the log files. + // be logged. The path can contain strftime-placeholders in order to split the log files. // If this string is empty or PersistFS is nil, the sessions will not be logged. LogPattern string @@ -319,7 +319,9 @@ func (r *registry) Register(id string, conf CollectorConfig) (Collector, error) return nil, fmt.Errorf("a collector with the ID '%s' already exists", id) } - m, err := newCollector(id, r.persist.sessionsCh, r.logger, conf) + collectHistory := r.persist.fs != nil && r.persist.interval >= 0 + + m, err := newCollector(id, r.persist.sessionsCh, r.logger, collectHistory, conf) if err != nil { return nil, err } @@ -360,7 +362,7 @@ func (r *registry) unregister(id string) error { delete(r.collector, id) - if r.persist.fs != nil { + if r.persist.fs != nil && r.persist.interval >= 0 { s, err := m.Snapshot() if err != nil { return err