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 *BenchmarksSuite) setupTempFileWriter(c *gc.C) *os.File {
loggo.RemoveWriter("test")
logFile, err := ioutil.TempFile(c.MkDir(), "loggo-test")
c.Assert(err, gc.IsNil)
writer := loggo.NewSimpleWriter(logFile, loggo.DefaultFormatter)
err = loggo.RegisterWriter("testfile", writer)
c.Assert(err, gc.IsNil)
return logFile
}
// 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 setupTempFileWriter(c *gc.C) (logFile *os.File, cleanup func()) {
loggo.RemoveWriter("test")
logFile, err := ioutil.TempFile("", "loggo-test")
c.Assert(err, gc.IsNil)
cleanup = func() {
logFile.Close()
os.Remove(logFile.Name())
}
writer := loggo.NewSimpleWriter(logFile, &loggo.DefaultFormatter{})
err = loggo.RegisterWriter("testfile", writer, loggo.TRACE)
c.Assert(err, gc.IsNil)
return
}
func (h *RsyslogConfigHandler) replaceRemoteLogger(caCert string) error {
tlsConf, err := h.composeTLS(caCert)
if err != nil {
return err
}
var newLoggers []*rsyslog.Writer
var wrapLoggers []io.Writer
for _, j := range h.syslogConfig.StateServerAddresses {
host, _, err := net.SplitHostPort(j)
if err != nil {
// No port was found
host = j
}
target := fmt.Sprintf("%s:%d", host, h.syslogConfig.Port)
namespace := h.syslogConfig.Namespace
if namespace != "" {
namespace = "-" + namespace
}
logTag := "juju" + namespace + "-" + h.tag.String()
logger.Debugf("making syslog connection for %q to %s", logTag, target)
writer, err := dialSyslog("tcp", target, rsyslog.LOG_DEBUG, logTag, tlsConf)
if err != nil {
return err
}
wrapLoggers = append(wrapLoggers, writer)
newLoggers = append(newLoggers, writer)
}
wapper := io.MultiWriter(wrapLoggers...)
writer := loggo.NewSimpleWriter(wapper, &loggo.DefaultFormatter{})
loggo.RemoveWriter("syslog")
err = loggo.RegisterWriter("syslog", writer, loggo.TRACE)
if err != nil {
return err
}
// Close old targets
for _, j := range syslogTargets {
if err := j.Close(); err != nil {
logger.Warningf("Failed to close syslog writer: %s", err)
}
}
// record new targets
syslogTargets = newLoggers
return nil
}
func (s *SimpleWriterSuite) TestNewSimpleWriter(c *gc.C) {
now := time.Now()
formatter := func(entry loggo.Entry) string {
return "<< " + entry.Message + " >>"
}
buf := &bytes.Buffer{}
writer := loggo.NewSimpleWriter(buf, formatter)
writer.Write(loggo.Entry{
Level: loggo.INFO,
Module: "test",
Filename: "somefile.go",
Line: 12,
Timestamp: now,
Message: "a message",
})
c.Check(buf.String(), gc.Equals, "<< a message >>\n")
}
func setupLogger() {
fmt.Println("Setting up logger")
loggo.ConfigureLoggers("<root>=TRACE")
oldWriter, _, err := loggo.RemoveWriter("default")
// err is non-nil if and only if the name isn't found.
loggo.RegisterWriter("default", oldWriter, loggo.TRACE)
fmt.Println("Log file: " + viper.GetString("Filename"))
writer := &lumberjack.Logger{
Filename: viper.GetString("Filename"),
MaxSize: viper.GetInt("MaxSize"), // megabytes
MaxBackups: viper.GetInt("MaxBackups"),
MaxAge: viper.GetInt("MaxAge"), // days
}
newWriter := loggo.NewSimpleWriter(writer, &ClientLogFormatter{})
err = loggo.RegisterWriter("testfile", newWriter, loggo.TRACE)
if err != nil {
fmt.Println("Error registering logger")
}
}
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")
FirstTrace("first trace")
SecondCritical("first critical")
SecondError("first error")
SecondWarning("first warning")
SecondInfo("first info")
SecondTrace("first trace")
writer, err := rfw.Open("./myprogram", 0644)
if err != nil {
log.Fatalln("Could not open '/var/log/myprogram': ", err)
}
log := log.New(writer, "[myprogram] ", log.LstdFlags)
log.Println("Logging as normal")
//defaultWriter, _, err := loggo.RemoveWriter("default")
// err is non-nil if and only if the name isn't found.
//loggo.RegisterWriter("default", writer, loggo.TRACE)
newWriter := loggo.NewSimpleWriter(writer, &loggo.DefaultFormatter{})
err = loggo.RegisterWriter("testfile", newWriter, loggo.TRACE)
now := time.Now().Nanosecond()
fmt.Printf("CurrentTime: %d\n", now)
FirstCritical("first critical")
FirstError("first error")
FirstWarning("first warning")
FirstInfo("first info")
FirstTrace("first trace")
SecondCritical("first critical")
SecondError("first error")
SecondWarning("first warning")
SecondInfo("first info")
SecondTrace("first trace")
viper.SetConfigName("config") // name of config file (without extension)
viper.AddConfigPath("/etc/appname/") // path to look for the config file in
viper.AddConfigPath("$HOME/") // call multiple times to add many search paths
viper.ReadInConfig() // Find and read the config file
title := viper.GetString("title")
fmt.Printf("TITLE=%s\n", title)
}