func init() { logger, err := log.LoggerFromConfigAsFile("seelog.xml") if err != nil { panic(err) } log.ReplaceLogger(logger) }
func main() { //err := LoadConfig("/system/etc/conf.json") err := LoadConfig("./conf.json") if err != nil { fmt.Printf("LoadConfig failed: (%s)", err) os.Exit(1) } //logger, err := log.LoggerFromConfigAsFile("/system/etc/log.xml") logger, err := log.LoggerFromConfigAsFile("./log.xml") if err != nil { fmt.Printf("Load log config failed: (%s)\n", err) os.Exit(1) } log.ReplaceLogger(logger) //wg := &sync.WaitGroup{} agent := NewAgent() c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT) wg := sync.WaitGroup{} wg.Add(1) go func() { agent.Run() log.Infof("agent quited") wg.Done() }() sig := <-c log.Infof("Received signal '%v', exiting\n", sig) agent.Stop() wg.Wait() }
func initAppConfig() { logger, err := seelog.LoggerFromConfigAsFile("./config/log.xml") if err != nil { log.Fatalln(err) } Logger = logger }
func InitLogger(configFile string) { fmt.Fprintln(os.Stderr, "Use "+configFile+" init Logger") m.Lock() defer m.Unlock() if loggerInitd { Errorf("Logger has been already inited.") return } seelogger, err := seelog.LoggerFromConfigAsFile(configFile) if err != nil { log.Panicf("Can't init Logger,error:%s", err) return } else { //确保取得正确的调用堆栈 seelogger.SetAdditionalStackDepth(2) } realLogger := logger.(*SeeLogLogger) if realLogger.seelogger != nil { realLogger.seelogger.Flush() realLogger.seelogger.Close() } realLogger.seelogger = seelogger loggerInitd = true }
func SeelogConfig() seelog.LoggerInterface { logger, err := seelog.LoggerFromConfigAsFile("seelog_config.xml") if err != nil { fmt.Println(err) return nil } return logger }
func LoadConf(configPath string) { DisableLog() logger, err := seelog.LoggerFromConfigAsFile(configPath) if err != nil { panic(err) } UseLogger(logger) }
func InitLogger(configPath string) { logger, err := seelog.LoggerFromConfigAsFile(configPath) if err != nil { fmt.Println(err) os.Exit(-1) } seelog.ReplaceLogger(logger) }
func loadAppConfig() { logger, err := seelog.LoggerFromConfigAsFile("./seelog.xml") if err != nil { fmt.Println(err) return } UseLogger(logger) }
func updateLogger() error { logger, err := log.LoggerFromConfigAsFile(LOGGER_CONFIG) if err != nil { return err } return log.ReplaceLogger(logger) }
func InitSeeLog(seeLogCfgFile string) { logger, err := log.LoggerFromConfigAsFile(seeLogCfgFile) if err != nil { log.Errorf("Parse seelog config file error: %s", err.Error) os.Exit(1) } log.ReplaceLogger(logger) }
func main() { defer log.Flush() logger, err := log.LoggerFromConfigAsFile("seelog.xml") if nil != err { log.Warn("Failed to load config", err) } log.ReplaceLogger(logger) flag.Parse() statsTransformChannel := make(chan *diskStat.DiskStat, 10) statsOutputChannel := make(chan *diskStat.ExtendedIoStats, 10) var output outputInterface.Output proto := PStdOut switch *protocolType { case "protobuffers": { proto = PProtoBuffers } case "json": { proto = PJson } default: { if *outputType == "zmq" { proto = PProtoBuffers } else if *outputType == "stdout" { proto = PStdOut } } } switch *outputType { case "zmq": output, err = zmqOutput.NewZmqOutput(queueUrl, proto) case "nano": output, err = nanoMsgOutput.NewNanoMsgOutput(queueUrl, proto) default: output = &logOutput.LogOutput{proto} } if nil != err { log.Error("Failed to setup output ", err) } go ioStatTransform.TransformStat(statsTransformChannel, statsOutputChannel) go statsOutput.Output(statsOutputChannel, output) for { readAndSendStats(statsTransformChannel) time.Sleep(time.Second * time.Duration(*interval)) } close(statsTransformChannel) close(statsOutputChannel) }
func log_init() { defer log.Flush() logger, e := log.LoggerFromConfigAsFile(GetConfigDir() + "/log.conf") if e != nil { log.Criticalf("Error %v", e) } log.ReplaceLogger(logger) //TODO timer watch config file }
func main() { cfgfile := "conf.json" begin := 0 count := 1 if len(os.Args) >= 3 { begin, _ = strconv.Atoi(os.Args[1]) count, _ = strconv.Atoi(os.Args[2]) } r, err := os.Open(cfgfile) if err != nil { fmt.Printf("failed to open config file %s", cfgfile) os.Exit(1) } var config Config decoder := json.NewDecoder(r) err = decoder.Decode(&config) if err != nil { fmt.Printf("invalid config file") os.Exit(1) } if config.ReadTimeout <= 0 { config.ReadTimeout = time.Duration(20) } logger, err := log.LoggerFromConfigAsFile("log.xml") if err != nil { fmt.Printf("Load log config failed: (%s)\n", err) os.Exit(1) } log.ReplaceLogger(logger) server, _ := net.ResolveTCPAddr("tcp4", config.Server) wg := &sync.WaitGroup{} c := make(chan os.Signal, 1) ctrl := make(chan bool, 1) signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT) running := true wg.Add(1) go func() { sig := <-c log.Infof("Received signal '%v', exiting\n", sig) running = false close(ctrl) wg.Done() }() for n := begin; n < begin+count; n++ { if !running { break } go runClient(n, &config, wg, ctrl, nil, server) time.Sleep(config.Interval * time.Millisecond) } wg.Wait() }
func loadAppConfig() { //logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig)) logger, err := seelog.LoggerFromConfigAsFile("conf/seelog.xml") if err != nil { fmt.Println(err) return } UseLogger(logger) }
func NewLogger(cfgfile string) *BurrowLogger { logger, err := log.LoggerFromConfigAsFile(cfgfile) if err != nil { log.Criticalf("Cannot start logger: %v", err) os.Exit(1) } log.ReplaceLogger(logger) return &BurrowLogger{logger} }
func main() { configFile := flag.String("cfg", "", "The config file") testSummary := flag.Bool("testSummary", false, "Test summary mode") flag.Parse() file, err := os.Open(*configFile) errHndlr(err, FATAL) decoder := json.NewDecoder(file) config := &StartupConfig{} err = decoder.Decode(&config) errHndlr(err, FATAL) if config.RedisInterval == 0 { config.RedisInterval = defaultRedisInterval } logger, err := log.LoggerFromConfigAsFile(config.SeelogConfig) defer log.Flush() if err != nil { panic("error reading " + config.SeelogConfig) } fmt.Println("Replacing logger, see log file according to " + config.SeelogConfig) if *testSummary { fmt.Println("WARNING: testSummary is on!") } log.ReplaceLogger(logger) runtime.GOMAXPROCS(runtime.NumCPU()) runningConfig, nil := getTmData(config, true) go houseKeeping(runningConfig, *testSummary) freeList := NewPool(16, config.RedisString) <-time.NewTimer(time.Now().Truncate(time.Duration(config.RedisInterval) * time.Second).Add(time.Duration(config.RedisInterval) * time.Second).Sub(time.Now())).C tickerChan := time.Tick(time.Duration(config.RedisInterval) * time.Second) for now := range tickerChan { if now.Second() == 30 { trc, err := getTmData(config, false) if err == nil { runningConfig = trc } } for cdnName, urls := range runningConfig.HealthUrls { for _, url := range urls { // log.Info(cdnName, " ", statName, " -> ", url) if *testSummary { fmt.Println("Skipping stat write - testSummary mode is ON!") continue } go rascalToRedis(cdnName, url, runningConfig.CacheGroupMap, freeList, config) } } } }
func loadConfig() { // PJ直下で実装した場合 logger, err := log.LoggerFromConfigAsFile("./conf/seelog/development.xml") if err != nil { panic("fail to load config") } log.ReplaceLogger(logger) }
// init log by config func (s *BaseService) initlog() { if s.Cfg.Log != "" { if logger, err := log.LoggerFromConfigAsFile(s.Cfg.Log); err == nil { log.ReplaceLogger(logger) } } // init echo log s.echo.SetLogger(NewEchoLogger()) }
func initializeLogging() { logger, err := log.LoggerFromConfigAsFile("config/logconfig.xml") if err != nil { log.Criticalf("An error occurred whilst initializing logging\n", err.Error()) panic(err) } log.ReplaceLogger(logger) }
func loadLogConfig(configFile string) { // check for custom logging if logger, err := log.LoggerFromConfigAsFile(configFile); err != nil { log.Errorf("[Server] Error loading custom logging config from %s: %v", configFile, err) } else { log.ReplaceLogger(logger) glob.Logger = logger log.Infof("[Server] Custom logging enabled from %s", configFile) } }
func main() { var ( flConfig = flag.String("c", "./etc/conf.json", "Config file") ) flag.Parse() err := conf.LoadConfig(*flConfig) if err != nil { fmt.Printf("LoadConfig (%s) failed: (%s)\n", *flConfig, err) os.Exit(1) } logger, err := log.LoggerFromConfigAsFile("./etc/log.xml") if err != nil { fmt.Printf("Load log config failed: (%s)\n", err) os.Exit(1) } log.ReplaceLogger(logger) waitGroup := &sync.WaitGroup{} cometServer := comet.NewServer() listener, err := cometServer.Init(conf.Config.Comet) if err != nil { log.Criticalf("Failed to start comet server: %s", err.Error()) os.Exit(1) } cometServer.SetAcceptTimeout(time.Duration(conf.Config.AcceptTimeout) * time.Second) cometServer.SetReadTimeout(time.Duration(conf.Config.ReadTimeout) * time.Second) cometServer.SetHeartbeatTimeout(time.Duration(conf.Config.HeartbeatTimeout) * time.Second) c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT) go func() { sig := <-c log.Infof("Received signal '%v', exiting\n", sig) ///utils.RemovePidFile(srv. runtime.config.Pidfile) cometServer.Stop() log.Infof("leave 1") waitGroup.Done() log.Infof("leave 2") }() go func() { cometServer.Run(listener) }() waitGroup.Add(1) go api.StartHttp(conf.Config.Web) waitGroup.Wait() }
//package 初始化 func init() { //读取配置文件,创建logger newLogger, err := log.LoggerFromConfigAsFile("conf/log.xml") if err != nil { fmt.Println("logger initial failed!") return } log.ReplaceLogger(newLogger) defaultLogger = log.Current defaultLogger.Info("logger initial success!") }
// Initialize logging from command arguments. func initLogging(configFile string) { var err error log.RegisterReceiver("stderr", &CustomReceiver{}) if configFile == "" { logger, err = log.LoggerFromConfigAsString(defaultLoggingConfig) checkLogFatal("Failed to load default logging configuration: %s", err) } else { logger, err = log.LoggerFromConfigAsFile(configFile) checkLogFatal("Failed to initialize custom logging file %s: %s", configFile, err) } }
func loadLogger() { logger, err := log.LoggerFromConfigAsFile("logger.xml") if err != nil { log.Error("Can not load the logger configuration file, Please check if the file logger.xml exists on current directory", err) os.Exit(1) } else { log.ReplaceLogger(logger) logger.Flush() } }
func ChangeLogEnv(kind int) { //开发环境 if kind == 1 { logger, err := log.LoggerFromConfigAsFile("config/logconfig_debug.xml") if err != nil { log.Errorf("create log error,error is %s ", err.Error()) } log.UseLogger(logger) } else if kind == 2 { //生产环境 logger, err := log.LoggerFromConfigAsFile("config/logconfig_production.xml") if err != nil { log.Errorf("create log error,error is %s ", err.Error()) } log.UseLogger(logger) } else { Error("can't recognize log environment") } }
func main() { defer log.Flush() logger, err := log.LoggerFromConfigAsFile("seelog.xml") rep.ReporterConfig("ipc:///temp/testSender.ipc", 0) r := rep.NewReporter() defer r.Close() if err != nil { log.Warn("Failed to load config", err) } log.ReplaceLogger(logger) start.Run() }
func main() { flag.Parse() logger, err := log.LoggerFromConfigAsFile("seelog.xml") if err != nil { log.Critical("err parsing config file", err) return } log.ReplaceLogger(logger) count = readFile(*bidResFile) http.HandleFunc(*path, DspServe) http.ListenAndServe(":"+*port, nil) }
func main() { defer log.Flush() logger, err := log.LoggerFromConfigAsFile("seelog.xml") if err != nil { log.Warn("Failed to load logger config", err) } else { log.ReplaceLogger(logger) } rest.StartServer() }
func InitLoggerByConfig(fileName string) { defer func() { logConfigLocker.Unlock() }() logConfigLocker.Lock() logger, err := log.LoggerFromConfigAsFile(fileName) if err != nil { log.Errorf("Can not create log from config file. FileName: %s", fileName) return } log.ReplaceLogger(logger) }
func main() { logConfigFile := flag.String("l", "./conf/log.xml", "Log config file") configFile := flag.String("c", "./conf/conf.json", "Config file") flag.Parse() logger, err := log.LoggerFromConfigAsFile(*logConfigFile) if err != nil { fmt.Printf("Load log config failed: (%s)\n", err) os.Exit(1) } log.ReplaceLogger(logger) err = conf.LoadConfig(*configFile) if err != nil { log.Warnf("LoadConfig (%s) failed: (%s)\n", *configFile, err) os.Exit(1) } http.HandleFunc("/api/v1/notify", postNotify) err = http.ListenAndServe(conf.Config.Notify.Addr, nil) if err != nil { log.Warnf("failed to ListenAndServe: ", err) os.Exit(1) } }