func (*loggerSuite) TestLocationCapture(c *gc.C) {
writer := &loggo.TestWriter{}
loggo.ReplaceDefaultWriter(writer)
logger := loggo.GetLogger("test")
logger.SetLogLevel(loggo.TRACE)
logger.Criticalf("critical message") //tag critical-location
logger.Errorf("error message") //tag error-location
logger.Warningf("warning message") //tag warning-location
logger.Infof("info message") //tag info-location
logger.Debugf("debug message") //tag debug-location
logger.Tracef("trace message") //tag trace-location
log := writer.Log()
tags := []string{
"critical-location",
"error-location",
"warning-location",
"info-location",
"debug-location",
"trace-location",
}
c.Assert(log, gc.HasLen, len(tags))
for x := range tags {
assertLocation(c, log[x], tags[x])
}
}
func main() {
args := os.Args
if len(args) > 1 {
loggo.ConfigureLoggers(args[1])
} else {
fmt.Println("Add a parameter to configure the logging:")
fmt.Println("E.g. \"<root>=INFO;first=TRACE\"")
}
fmt.Println("\nCurrent logging levels:")
fmt.Println(loggo.LoggerInfo())
fmt.Println("")
rootLogger.Infof("Start of test.")
FirstCritical("first critical")
FirstError("first error")
FirstWarning("first warning")
FirstInfo("first info")
FirstDebug("first debug")
FirstTrace("first trace")
loggo.ReplaceDefaultWriter(loggo.NewSimpleWriter(os.Stderr, &loggo.ColorFormatter{}))
SecondCritical("second critical")
SecondError("second error")
SecondWarning("second warning")
SecondInfo("second info")
SecondDebug("second debug")
SecondTrace("second trace")
}
func (s *LoggingSuite) setUp(c *gc.C) {
loggo.ResetWriters()
loggo.ReplaceDefaultWriter(&gocheckWriter{c})
loggo.ResetLoggers()
err := loggo.ConfigureLoggers(logConfig)
c.Assert(err, gc.IsNil)
}
func (s *JujuLogSuite) TestBadges(c *gc.C) {
tw := &loggo.TestWriter{}
_, err := loggo.ReplaceDefaultWriter(tw)
loggo.GetLogger("unit").SetLogLevel(loggo.TRACE)
c.Assert(err, gc.IsNil)
hctx := s.GetHookContext(c, -1, "")
assertLogs(c, hctx, tw, "u/0", "")
hctx = s.GetHookContext(c, 1, "u/1")
assertLogs(c, hctx, tw, "u/0", "peer1:1: ")
}
// Start starts logging using the given Context.
func (log *Log) Start(ctx *Context) error {
if log.Verbose && log.Quiet {
return fmt.Errorf(`"verbose" and "quiet" flags clash, please use one or the other, not both`)
}
ctx.quiet = log.Quiet
ctx.verbose = log.Verbose
if log.Path != "" {
path := ctx.AbsPath(log.Path)
target, err := os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
return err
}
writer := log.GetLogWriter(target)
err = loggo.RegisterWriter("logfile", writer)
if err != nil {
return err
}
}
level := loggo.WARNING
if log.ShowLog {
level = loggo.INFO
}
if log.Debug {
log.ShowLog = true
level = loggo.DEBUG
// override quiet or verbose if set, this way all the information goes
// to the log file.
ctx.quiet = true
ctx.verbose = false
}
if log.ShowLog {
// We replace the default writer to use ctx.Stderr rather than os.Stderr.
writer := log.GetLogWriter(ctx.Stderr)
_, err := loggo.ReplaceDefaultWriter(writer)
if err != nil {
return err
}
} else {
loggo.RemoveWriter("default")
// Create a simple writer that doesn't show filenames, or timestamps,
// and only shows warning or above.
writer := NewWarningWriter(ctx.Stderr)
err := loggo.RegisterWriter("warning", writer)
if err != nil {
return err
}
}
// Set the level on the root logger.
root := loggo.GetLogger("")
root.SetLogLevel(level)
// Override the logging config with specified logging config.
loggo.ConfigureLoggers(log.Config)
return nil
}
func (s *LoggingSuite) setUp(c *gc.C) {
loggo.ResetWriters()
// Don't use the default writer for the test logging, which
// means we can still get logging output from tests that
// replace the default writer.
loggo.ReplaceDefaultWriter(discardWriter{})
loggo.RegisterWriter("loggingsuite", &gocheckWriter{c}, loggo.TRACE)
loggo.ResetLoggers()
err := loggo.ConfigureLoggers(logConfig)
c.Assert(err, gc.IsNil)
}
// setupLogging redirects logging to rolled log files.
//
// NOTE: do not use this in the bootstrap agent, or
// if you do, change the bootstrap error reporting.
func setupAgentLogging(conf agent.Config) error {
filename := filepath.Join(conf.LogDir(), conf.Tag().String()+".log")
log := &lumberjack.Logger{
Filename: filename,
MaxSize: 300, // megabytes
MaxBackups: 2,
}
writer := loggo.NewSimpleWriter(log, &loggo.DefaultFormatter{})
_, err := loggo.ReplaceDefaultWriter(writer)
return err
}
func (s *LogMatchesSuite) TestFromLogMatches(c *gc.C) {
tw := &loggo.TestWriter{}
_, err := loggo.ReplaceDefaultWriter(tw)
c.Assert(err, gc.IsNil)
defer loggo.ResetWriters()
logger := loggo.GetLogger("test")
logger.SetLogLevel(loggo.DEBUG)
logger.Infof("foo")
logger.Debugf("bar")
logger.Tracef("hidden")
c.Check(tw.Log, jc.LogMatches, []string{"foo", "bar"})
c.Check(tw.Log, gc.Not(jc.LogMatches), []string{"foo", "bad"})
c.Check(tw.Log, gc.Not(jc.LogMatches), []jc.SimpleMessage{
{loggo.INFO, "foo"},
{loggo.INFO, "bar"},
})
}
func (*loggerSuite) TestLoggingStrings(c *gc.C) {
writer := &loggo.TestWriter{}
loggo.ReplaceDefaultWriter(writer)
logger := loggo.GetLogger("test")
logger.SetLogLevel(loggo.TRACE)
logger.Infof("simple")
checkLastMessage(c, writer, "simple")
logger.Infof("with args %d", 42)
checkLastMessage(c, writer, "with args 42")
logger.Infof("working 100%")
checkLastMessage(c, writer, "working 100%")
logger.Infof("missing %s")
checkLastMessage(c, writer, "missing %s")
}
func (*writerBasicsSuite) TestReplaceDefaultWriterNoDefault(c *gc.C) {
loggo.RemoveWriter("default")
oldWriter, err := loggo.ReplaceDefaultWriter(&loggo.TestWriter{})
c.Assert(oldWriter, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `there is no "default" writer`)
}
func (*writerBasicsSuite) TestReplaceDefaultWriterWithNil(c *gc.C) {
oldWriter, err := loggo.ReplaceDefaultWriter(nil)
c.Assert(oldWriter, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "Writer cannot be nil")
}
func (*writerBasicsSuite) TestReplaceDefaultWriter(c *gc.C) {
oldWriter, err := loggo.ReplaceDefaultWriter(&loggo.TestWriter{})
c.Assert(oldWriter, gc.NotNil)
c.Assert(err, gc.IsNil)
}
func (*GlobalSuite) TestReplaceDefaultWriter(c *gc.C) {
oldWriter, err := loggo.ReplaceDefaultWriter(&writer{})
c.Assert(oldWriter, gc.NotNil)
c.Assert(err, gc.IsNil)
c.Assert(loggo.DefaultContext().WriterNames(), gc.DeepEquals, []string{"default"})
}
func (t *LoggingSuite) setUp(c *gc.C) {
loggo.ResetWriters()
loggo.ReplaceDefaultWriter(&gocheckWriter{c})
loggo.ResetLoggers()
}