func dateTimeFormat() {
fmt.Println("Date time format")
testConfig := `
<seelog type="sync">
<outputs formatid="main">
<console/>
</outputs>
<formats>
<format id="main" format="%Date/%Time [%LEV] %Msg%n"/>
</formats>
</seelog>`
logger, err := log.LoggerFromConfigAsBytes([]byte(testConfig))
if err != nil {
fmt.Println(err)
}
loggerErr := log.ReplaceLogger(logger)
if loggerErr != nil {
fmt.Println(loggerErr)
}
log.Trace("Test message!")
}
// path can be ""
func InitLog(path string, debug bool) {
config := `
<seelog type="sync" minlevel="${minlevel}">
<outputs formatid="main">
<console/>
<!-- ${extra} -->
</outputs>
<formats>
<format id="main" format="[EQ-%LEV] %Date(15:04:05.00): %Msg (at %File:%Line) %n"/>
</formats>
</seelog>`
if path != "" {
extra := fmt.Sprintf("<file path=\"%s\"/>", path)
config = strings.Replace(config, "<!-- ${extra} -->",
extra, -1)
}
Debug = debug
if debug {
config = strings.Replace(config, "${minlevel}", "debug", -1)
} else {
config = strings.Replace(config, "${minlevel}", "info", -1)
}
logger, err := seelog.LoggerFromConfigAsBytes([]byte(config))
if err != nil {
panic(err)
}
seelog.ReplaceLogger(logger)
if path != "" {
seelog.Debugf("Initialized the logger for %s", path)
}
}
func NewLogs() {
logger, err := log.LoggerFromConfigAsBytes([]byte(default_template))
if err != nil {
log.Criticalf("log config err: %v", err)
}
log.ReplaceLogger(logger)
}
func configLogger() {
config := `
<seelog type="sync">
<outputs>
<filter levels="trace">
<console formatid="skipped"/>
</filter>
<filter levels="debug">
<console formatid="unchanged"/>
</filter>
<filter levels="info">
<console formatid="plain"/>
</filter>
<filter levels="warn,error,critical">
<console formatid="error"/>
</filter>
</outputs>
<formats>
<format id="error" format="%EscM(31)%Msg%EscM(0)%n"/>
<format id="plain" format="%Msg%n"/>
<format id="unchanged" format="%EscM(32)%Msg%EscM(0)%n"/>
<format id="skipped" format="%EscM(34)%Msg%EscM(0)%n"/>
</formats>
</seelog>`
logger, err := log.LoggerFromConfigAsBytes([]byte(config))
if err != nil {
panic(err)
}
log.ReplaceLogger(logger)
}
func configureLog() {
level := Get("lamp.log.level")
if level == "" {
level = "warn"
printVerboseMessage("Could not get log level from configuration, will use default \"warn\".")
}
logDir := os.Getenv(logDir)
var outPath string
logFile := Get("lamp.log.file")
if logFile == "" {
logFile = "lamp.log"
printVerboseMessage("Could not get log filename from configuration. \"lamp.log\" will be used as log filename.")
}
if logDir != "" {
outPath = logDir + sep + logFile
printVerboseMessage("Will write logs to: \n" + outPath)
} else {
outPath = lampHome() + "logs" + sep + logFile
printVerboseMessage("LAMP_LOGS_DIR environment variable is not set. Will write logs to: \n" + outPath)
}
logConfig := template(outPath, level)
logger, err := seelog.LoggerFromConfigAsBytes([]byte(logConfig))
if err != nil {
fmt.Printf("Error occured while configuring logger: %s\n", err.Error())
}
log.UseLogger(logger)
}
func testFuncException() {
fmt.Println("testFuncException")
testConfig := `
<seelog type="sync" minlevel="info">
<exceptions>
<exception funcpattern="*main.test*Except*" minlevel="error"/>
</exceptions>
<outputs>
<console/>
</outputs>
</seelog>`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
log.Trace("NOT Printed")
log.Debug("NOT Printed")
log.Info("NOT Printed")
log.Warn("NOT Printed")
log.Error("Printed")
log.Critical("Printed")
log.Current.Trace("NOT Printed")
log.Current.Debug("NOT Printed")
log.Current.Info("NOT Printed")
log.Current.Warn("NOT Printed")
log.Current.Error("Printed")
log.Current.Critical("Printed")
}
// ConfigureLogger configures the new logger according to the configuration and sets it as the current logger.
func ConfigureLogger(testConfig []byte) {
loggr, err := seelog.LoggerFromConfigAsBytes([]byte(testConfig))
if err != nil {
fmt.Printf("error occured: %s\n", err.Error())
}
UseLogger(loggr)
}
func setup_logging() {
level := "info"
if *g_debug == true {
level = "debug"
}
config := fmt.Sprintf(`
<seelog type="sync" minlevel="%s">
<outputs formatid="main">
<console/>
</outputs>
<formats>
<format id="main" format="%%Date %%Time [%%LEVEL] %%File|%%FuncShort|%%Line: %%Msg%%n"/>
</formats>
</seelog>`, level)
logger, err := log.LoggerFromConfigAsBytes([]byte(config))
if err != nil {
fmt.Println("Failed to config logging:", err)
os.Exit(1)
}
log.ReplaceLogger(logger)
log.Info("Logging config is successful")
}
func TestGosnmp(t *testing.T) {
RegisterFailHandler(Fail)
pid := os.Getpid()
loggingConfig := fmt.Sprintf(`
<seelog>
<outputs>
<buffered size="10000" flushperiod="1000" formatid="debug">
<rollingfile type="size" filename="logs/debuglog.log" maxsize="10000000" maxrolls="10" />
</buffered>
</outputs>
<formats>
<format id="debug" format="%d %%Date(Mon Jan _2 15:04:05.000000) [%%LEV] %%File:%%Line %%Msg%%n"/>
</formats>
</seelog>`, pid)
logger, err := seelog.LoggerFromConfigAsBytes([]byte(loggingConfig))
if err != nil {
Fail(fmt.Sprintf("Couldn't initialize logger: %s", err))
}
defer logger.Flush()
testIdGenerator := make(chan string)
go func() {
for i := 0; ; i++ {
testIdGenerator <- fmt.Sprintf("test %-3d", i)
}
}()
setupV2cClientTest(logger, testIdGenerator)
SetupLowLevelContextTest(logger, testIdGenerator)
RunSpecs(t, "gosnmp Suite")
}
func SetupTestLogging() {
var appConfig = `
<seelog type="sync" minlevel='%s'>
<outputs formatid="scanner">
<filter levels="critical,error,warn,info">
<console formatid="scanner" />
</filter>
<filter levels="debug,trace">
<console formatid="debug" />
</filter>
</outputs>
<formats>
<format id="scanner" format="test: [%%LEV] %%Msg%%n" />
<format id="debug" format="test: [%%LEV] %%Func :: %%Msg%%n" />
</formats>
</seelog>
`
var config string
if testing.Verbose() {
config = fmt.Sprintf(appConfig, "trace")
} else {
config = fmt.Sprintf(appConfig, "info")
}
logger, err := log.LoggerFromConfigAsBytes([]byte(config))
if err != nil {
fmt.Println(err)
return
}
log.ReplaceLogger(logger)
}
func loadAppConfig() {
appConfig := `
<seelog minlevel="info">
<outputs formatid="common">
<rollingfile type="size" filename="/U8SOFT/turbocrm70/apache/logs/ws/roll.log" maxsize="100000" maxrolls="5"/>
<filter levels="critical">
<file path="/U8SOFT/turbocrm70/apache/logs/ws/critical.log" formatid="critical"/>
</filter>
<filter levels="error">
<file path="/U8SOFT/turbocrm70/apache/logs/ws/error.log" formatid="error"/>
</filter>
</outputs>
<formats>
<format id="common" format="%Date/%Time [%LEV] %Msg%n" />
<format id="critical" format="%File %FullPath %Func %Msg%n" />
<format id="error" format="%Date/%Time %File %FullPath %Func %Msg%n" />
</formats>
</seelog>`
logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig))
if err != nil {
fmt.Println(err)
return
}
UseLogger(logger)
}
func loadAppConfig() {
appConfig := `
<seelog type="adaptive" mininterval="2000000" maxinterval="100000000" critmsgcount="500" minlevel="debug">
<exceptions>
<exception filepattern="test*" minlevel="error"/>
</exceptions>
<outputs formatid="all">
<file path="all.log"/>
<filter levels="info">
<console formatid="fmtinfo"/>
</filter>
<filter levels="error,critical" formatid="fmterror">
<console/>
<file path="errors.log"/>
</filter>
</outputs>
<formats>
<format id="fmtinfo" format="[%Level] [%Time] %Msg%n"/>
<format id="fmterror" format="[%LEVEL] [%Time] [%FuncShort @ %File.%Line] %Msg%n"/>
<format id="all" format="[%Level] [%Time] [@ %File.%Line] %Msg%n"/>
<format id="criticalemail" format="Critical error on our server!\n %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
</formats>
</seelog>
`
logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig))
if err != nil {
fmt.Println(err)
return
}
UseLogger(logger)
}
func loadAppConf() {
// appConf := `<seelog />`
appConf := `
<seelog minlevel="warn">
<outputs formatid="common">
<rollingfile type="size" filename="/Users/winniewang/source/go-workspace/logs/roll.log" maxsize="100000" maxrolls="5"/>
<filter levels="critical">
<file path="/Users/winniewang/source/go-workspace/logs/critical.log" formatid="critical"/>
<smtp formatid="criticalemail" senderaddress="*****@*****.**" sendername="Zhou Zhefu" hostname="smtp.gmail.com" hostport="587" username="******" password="******">
<recipient address="*****@*****.**"/>
</smtp>
</filter>
</outputs>
<formats>
<format id="common" format="%Date/%Time [%LEV] %Msg%n" />
<format id="critical" format="%File %FullPath %Func %Msg%n" />
<format id="criticalemail" format="Critical error on our server!\n %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
</formats>
</seelog>
`
logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConf))
if err != nil {
fmt.Println(err)
return
}
UseLogger(logger)
}
func createLogger(logName string) (seelog.LoggerInterface, error) {
conf, err := createLogConf(logName)
if err != nil {
fmt.Println("build log conf err", err)
os.Exit(1)
}
return seelog.LoggerFromConfigAsBytes(conf)
}
func setLogLevel(level string) {
if level != "error" && level != "warn" {
log.Infof("Setting log level '%s'.", level)
}
logConfig := fmt.Sprintf("<seelog minlevel='%s'>", level)
logger, _ := log.LoggerFromConfigAsBytes([]byte(logConfig))
log.ReplaceLogger(logger)
}
// initLoggerFromBytes initializes the logger using the specified configuration as bytes.
func initLoggerFromBytes(seelogConfig []byte) (logger T) {
var seelogger seelog.LoggerInterface
var err error
if seelogger, err = seelog.LoggerFromConfigAsBytes(seelogConfig); err != nil {
fmt.Println("Error parsing logger config:", err)
return nil
}
seelogDefault = seelogger
return withContext(seelogDefault)
}
//Creates a new DefaultLogger that is configured to write messages to console with minimum log level Level.
func NewDefaultLogger(Level LogLevel) *DefaultLogger {
var config = fmt.Sprintf(`<seelog minlevel="%s">
<outputs formatid="main">
<console />
</outputs>
<formats>
<format id="main" format="%%Date/%%Time [%%LEVEL] %%Msg%%n"/>
</formats>
</seelog>`, Level)
logger, _ := log.LoggerFromConfigAsBytes([]byte(config))
return &DefaultLogger{Level, logger}
}
func rollingFileWriterManyRolls() {
testConfig := `
<seelog>
<outputs>
<rollingfile type="size" filename="./log/manyrolls.log" maxsize="100" maxrolls="4" />
</outputs>
</seelog>
`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
fmt.Println("Rolling file writer. Many rolls")
doLogBig()
}
func LoadLogConfig(name string) {
config := `<seelog type="adaptive" mininterval="2000000" maxinterval="10000000" critmsgcount="5">
<outputs formatid="msg">
<file path="` + name + `.log"/>
</outputs>
<formats>
<format id="msg" format="%Time: %Msg%n"/>
</formats>
</seelog>`
logger, _ := log.LoggerFromConfigAsBytes([]byte(config))
log.ReplaceLogger(logger)
}
func stdFormat() {
testConfig := `
<seelog type="sync">
<outputs formatid="main">
<console/>
</outputs>
<formats>
<format id="main" format=" %Date %Time - [%LEVEL] - %Msg - (%Func %File)%n"/>
</formats>
</seelog>`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
}
func consoleWriter() {
testConfig := `
<seelog>
<outputs>
<console />
</outputs>
</seelog>
`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
fmt.Println("Console writer")
doLog()
}
func defaultFormat() {
fmt.Println("Default format")
testConfig := `
<seelog type="sync" />`
logger, err := log.LoggerFromConfigAsBytes([]byte(testConfig))
if err != nil {
fmt.Println(err)
}
log.ReplaceLogger(logger)
log.Trace("Test message!")
}
func loadAdaptiveConfig() {
testConfig := `<seelog type="adaptive" mininterval="200000000" maxinterval="1000000000" critmsgcount="5">
<outputs formatid="msg">
<console/>
</outputs>
<formats>
<format id="msg" format="%Time: %Msg%n"/>
</formats>
</seelog>`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
}
func main() {
defer log.Flush()
logConfig := `
<seelog>
<outputs formatid="format1">
<rollingfile type="size" filename="./log/roll.log" maxsize="100" maxrolls="5" />
</outputs>
<formats>
<format id="format1" format="%Date/%Time [%LEV] %Msg%n"/>
</formats>
</seelog>
`
logger, err := log.LoggerFromConfigAsBytes([]byte(logConfig))
check(err)
log.ReplaceLogger(logger)
weatherStation.UseLogger(logger)
defer weatherStation.FlushLog()
connection, err := weatherStation.Connect()
check(err)
weatherStation.WakeUp(connection)
mqttClient, opts, err := StartMqttConnection()
check(err)
for {
var wg sync.WaitGroup
var dataChannel chan *weatherStation.WeatherData = make(chan *weatherStation.WeatherData)
wg.Add(1)
go weatherStation.GetCurrentData(connection, 30, dataChannel, &wg)
go PostCurrentData(dataChannel, mqttClient, opts)
wg.Wait()
mqttClient.Disconnect(100)
time.Sleep(time.Second * 1)
var connected bool = false
var i int = 1
for connected == false {
mqttClient, _, err = StartMqttConnection()
if err == nil {
connected = true
} else {
time.Sleep(time.Second * time.Duration(i))
log.Warnf("wait for %d second to try to reconnect mqtt broker", i)
i++
}
}
//time.Sleep(time.Second * 5)
}
log.Info("END")
}
func smtpWriter() {
testConfig := `
<seelog>
<outputs>
<smtp senderaddress="*****@*****.**" sendername="Automatic notification service" hostname="mail.none.org" hostport="587" username="******" password="******">
<recipient address="*****@*****.**"/>
</smtp>
</outputs>
</seelog>
`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
fmt.Println("SMTP writer is now sending emails to the specified recipients")
doLog()
}
func fileWriter() {
testConfig := `
<seelog>
<outputs>
<file path="./log/log.log"/>
</outputs>
</seelog>
`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
fmt.Println("File writer")
doLog()
}
func splitDispatcher() {
testConfig := `
<seelog>
<outputs>
<file path="./log/split.log"/>
<console />
</outputs>
</seelog>
`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
fmt.Println("Split dispatcher")
doLog()
}
func init() {
var seelogger seelog.LoggerInterface
var err error
fmt.Fprintln(os.Stderr, "Use default config init Logger")
seelogger, err = seelog.LoggerFromConfigAsBytes([]byte(defaultConfig))
if err != nil {
log.Panicf("Can't init Logger,error:%s", err)
return
} else {
//确保取得正确的调用堆栈
seelogger.SetAdditionalStackDepth(2)
}
logger = &SeeLogLogger{seelogger}
}
func InitLogging(level string) error {
config := fmt.Sprintf(`<seelog minlevel="%s">
<outputs formatid="main">
<console />
</outputs>
<formats>
<format id="main" format="%%Date/%%Time [%%LEVEL] %%Msg%%n"/>
</formats>
</seelog>`, level)
logger, err := log.LoggerFromConfigAsBytes([]byte(config))
Logger = logger
return err
}
func levelsFormatter() {
testConfig := `
<seelog type="sync">
<outputs formatid="main">
<console/>
</outputs>
<formats>
<format id="main" format="%MyLevel %Msg%n"/>
</formats>
</seelog>`
logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
log.ReplaceLogger(logger)
log.Trace("Test message!")
}