func (s *LogsSuite) TestPruneLogsByTime(c *gc.C) {
dbLogger := state.NewDbLogger(s.State, names.NewMachineTag("22"))
defer dbLogger.Close()
log := func(t time.Time, msg string) {
err := dbLogger.Log(t, "module", "loc", loggo.INFO, msg)
c.Assert(err, jc.ErrorIsNil)
}
now := time.Now()
maxLogTime := now.Add(-time.Minute)
log(now, "keep")
log(maxLogTime.Add(time.Second), "keep")
log(maxLogTime, "keep")
log(maxLogTime.Add(-time.Second), "prune")
log(maxLogTime.Add(-(2 * time.Second)), "prune")
noPruneMB := 100
err := state.PruneLogs(s.State, maxLogTime, noPruneMB)
c.Assert(err, jc.ErrorIsNil)
// After pruning there should just be 3 "keep" messages left.
var docs []bson.M
err = s.logsColl.Find(nil).All(&docs)
c.Assert(err, jc.ErrorIsNil)
c.Assert(docs, gc.HasLen, 3)
for _, doc := range docs {
c.Assert(doc["x"], gc.Equals, "keep")
}
}
func (w *pruneWorker) loop(stopCh <-chan struct{}) error {
p := w.params
for {
select {
case <-stopCh:
return tomb.ErrDying
case <-time.After(p.PruneInterval):
minLogTime := time.Now().Add(-p.MaxLogAge)
err := state.PruneLogs(w.st, minLogTime, p.MaxCollectionMB)
if err != nil {
return errors.Trace(err)
}
}
}
}
func (s *LogsSuite) TestPruneLogsBySize(c *gc.C) {
// Set up 3 environments and generate different amounts of logs
// for them.
now := time.Now().Truncate(time.Millisecond)
s0 := s.State
startingLogsS0 := 10
s.generateLogs(c, s0, now, startingLogsS0)
s1 := s.factory.MakeEnvironment(c, nil)
defer s1.Close()
startingLogsS1 := 10000
s.generateLogs(c, s1, now, startingLogsS1)
s2 := s.factory.MakeEnvironment(c, nil)
defer s2.Close()
startingLogsS2 := 12000
s.generateLogs(c, s2, now, startingLogsS2)
// Prune logs collection back to 1 MiB.
tsNoPrune := time.Now().Add(-3 * 24 * time.Hour)
err := state.PruneLogs(s.State, tsNoPrune, 1)
c.Assert(err, jc.ErrorIsNil)
// Logs for first env should not be touched.
c.Assert(s.countLogs(c, s0), gc.Equals, startingLogsS0)
// Logs for second env should be pruned.
c.Assert(s.countLogs(c, s1), jc.LessThan, startingLogsS1)
// Logs for third env should be pruned to a similar level as
// second env.
c.Assert(s.countLogs(c, s2), jc.LessThan, startingLogsS1)
// Ensure that the latest log records are still there.
assertLatestTs := func(st *state.State) {
var doc bson.M
err := s.logsColl.Find(bson.M{"e": st.EnvironUUID()}).Sort("-t").One(&doc)
c.Assert(err, jc.ErrorIsNil)
c.Assert(doc["t"].(time.Time), gc.Equals, now)
}
assertLatestTs(s0)
assertLatestTs(s1)
assertLatestTs(s2)
}
