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) }