func (s *GlobalSuite) TestConfigureLoggers(c *gc.C) {
err := loggo.ConfigureLoggers("testing.module=debug")
c.Assert(err, gc.IsNil)
expected := "<root>=WARNING;testing.module=DEBUG"
c.Assert(loggo.DefaultContext().Config().String(), gc.Equals, expected)
c.Assert(loggo.LoggerInfo(), gc.Equals, expected)
}
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 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")
}
// NewLogger returns a worker.Worker that uses the notify watcher returned
// from the setup.
func NewLogger(api *logger.State, agentConfig agent.Config) worker.Worker {
logger := &Logger{
api: api,
agentConfig: agentConfig,
lastConfig: loggo.LoggerInfo(),
}
log.Debugf("initial log config: %q", logger.lastConfig)
return worker.NewNotifyWorker(logger)
}
// NewLogger returns a worker.Worker that uses the notify watcher returned
// from the setup.
func NewLogger(api *logger.State, agentConfig agent.Config) (worker.Worker, error) {
logger := &Logger{
api: api,
agentConfig: agentConfig,
lastConfig: loggo.LoggerInfo(),
}
log.Debugf("initial log config: %q", logger.lastConfig)
w, err := watcher.NewNotifyWorker(watcher.NotifyConfig{
Handler: logger,
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
}
func (*loggerSuite) TestConfigureLoggers(c *gc.C) {
for i, test := range configureLoggersTests {
c.Logf("test %d: %q", i, test.spec)
loggo.ResetLoggers()
err := loggo.ConfigureLoggers(test.spec)
c.Check(loggo.LoggerInfo(), gc.Equals, test.info)
if test.err != "" {
c.Assert(err, gc.ErrorMatches, test.err)
continue
}
c.Assert(err, gc.IsNil)
// Test that it's idempotent.
err = loggo.ConfigureLoggers(test.spec)
c.Assert(err, gc.IsNil)
c.Assert(loggo.LoggerInfo(), gc.Equals, test.info)
// Test that calling ConfigureLoggers with the
// output of LoggerInfo works too.
err = loggo.ConfigureLoggers(test.info)
c.Assert(err, gc.IsNil)
c.Assert(loggo.LoggerInfo(), gc.Equals, test.info)
}
}
func (s *LoggerSuite) waitLoggingInfo(c *gc.C, expected string) {
timeout := time.After(worstCase)
for {
select {
case <-timeout:
c.Fatalf("timeout while waiting for logging info to change")
case <-time.After(10 * time.Millisecond):
loggerInfo := loggo.LoggerInfo()
if loggerInfo != expected {
c.Logf("logging is %q, still waiting", loggerInfo)
continue
}
return
}
}
}
func (c *Config) ensureUnitLogging() error {
loggingConfig := c.asString("logging-config")
// If the logging config hasn't been set, then look for the os environment
// variable, and failing that, get the config from loggo itself.
if loggingConfig == "" {
if environmentValue := os.Getenv(osenv.JujuLoggingConfigEnvKey); environmentValue != "" {
loggingConfig = environmentValue
} else {
loggingConfig = loggo.LoggerInfo()
}
}
levels, err := loggo.ParseConfigString(loggingConfig)
if err != nil {
return err
}
// If there is is no specified level for "unit", then set one.
if _, ok := levels["unit"]; !ok {
loggingConfig = loggingConfig + ";unit=DEBUG"
}
c.defined["logging-config"] = loggingConfig
return nil
}
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)
}