func InitLogger(logFile string, logFormat string, accessLogFile string, accessLogFormat string) {
loglevel := l4g.INFO
if conf.DebugMode {
loglevel = l4g.DEBUG
}
log = make(l4g.Logger)
flw := l4g.NewFileLogWriter(logFile, false)
flw.SetFormat(logFormat)
flw.SetRotate(false)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(false)
log.AddFilter("file", loglevel, flw)
accessLog = make(l4g.Logger)
aflw := l4g.NewFileLogWriter(accessLogFile, false)
aflw.SetFormat(accessLogFormat)
aflw.SetRotate(false)
aflw.SetRotateSize(0)
aflw.SetRotateLines(0)
aflw.SetRotateDaily(false)
accessLog.AddFilter("file", loglevel, aflw)
}
/*
Init - initialize log lib
RETURNS:
*Logger, nil - if succeed
nil, error - if fail
*/
func (l *Logger) Init() (*Logger, error) {
// check, and create dir if nonexist
if err := logDirCreate(l.logDir); err != nil {
return nil, err
}
// default level: INFO
level := log4go.INFO
if l.enableDebug {
level = log4go.DEBUG
}
// set logger format
logFormat := func(enableDebug bool) string {
if enableDebug {
return log4go.FORMAT_DEFAULT
}
return FORMAT_WITHOUT_SRC
}(l.enableDebug)
// create logger
logger := make(log4go.Logger)
// create writer for stdout
if l.enableStdout {
logger.AddFilter("stdout", level, log4go.NewConsoleLogWriter())
}
// create file writer for all log
fileName := filenameGen(l.progName, l.logDir, false)
logWriter := log4go.NewFileLogWriter(fileName, l.enableRotate)
if l.enableRotate {
logWriter.SetRotateSize(l.rotateSize)
logWriter.SetRotateDaily(true)
}
logWriter.SetFormat(logFormat)
logger.AddFilter("log", level, logWriter)
if l.enableWf {
fileNameWf := filenameGen(l.progName, l.logDir, true)
logWriterWf := log4go.NewFileLogWriter(fileNameWf, l.enableRotate)
if l.enableRotate {
logWriterWf.SetRotateSize(l.rotateSize)
logWriterWf.SetRotateDaily(true)
}
logWriterWf.SetFormat(logFormat)
logger.AddFilter("log_wf", log4go.WARNING, logWriterWf)
}
// set Logger
l.Logger = logger
return l, nil
}
func GetLogger(path string, level string) *Log {
var log Log
if path == "" {
path = DEFAULT_LOG_PATH
}
lv := log4go.ERROR
switch level {
case "debug":
lv = log4go.DEBUG
case "error":
lv = log4go.ERROR
case "info":
lv = log4go.INFO
}
l := log4go.NewDefaultLogger(lv)
//l.AddFilter("log", lv, log4go.NewFileLogWriter(path, true))
l.AddFilter("log", lv, log4go.NewFileLogWriter(path, false))
log.l = l
return &log
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
}
for _, filter := range log.Global {
filter.Level = level
}
if logFile == "stdout" {
log.AddFilter("stdout", level, log.NewConsoleLogWriter())
} else {
logDir := filepath.Dir(logFile)
if err := os.MkdirAll(logDir, 0744); err != nil {
panic(err)
}
writer := log.NewFileLogWriter(logFile, false)
log.AddFilter("file", level, writer)
writer.SetFormat("[%D %t] [%L] (%S) %M")
writer.SetRotate(true)
writer.SetRotateSize(0)
writer.SetRotateLines(0)
writer.SetRotateDaily(true)
}
}
func main() {
flag.Parse()
log4go.AddFilter("file", log4go.FINEST, log4go.NewFileLogWriter("debug.log", *rotateLog))
defer func() {
py.NewLock()
py.Finalize()
}()
if err := termbox.Init(); err != nil {
log4go.Exit(err)
}
defer func() {
termbox.Close()
log4go.Debug(util.Prof)
if err := recover(); err != nil {
log4go.Crash(err)
}
}()
var t tbfe
t.dorender = make(chan bool, render_chan_len)
t.layout = make(map[*backend.View]layout)
t.loop()
}
func main() {
// Set the static directory for webgo
path := os.Getenv("GOPATH")
if path == "" {
fmt.Println("GOPATH NOT SET")
return
}
filepath := fmt.Sprintf("%s/../frontend/src/", path)
web.Config.StaticDir = filepath
// Setup logging
log := make(l4g.Logger)
// Create a default logger that is logging messages of FINE or higher
l4g.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter("error_log.log", false))
log.Close()
// Setup the DB
db.Init(path)
// Parse command line arguments
port := flag.Int("port", 80, "port number to start the server on")
flag.Parse()
url := fmt.Sprintf("0.0.0.0:%d", *port)
// Start the server!
serve.Routes()
web.Run(url)
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
}
for _, filter := range log.Global {
filter.Level = level
}
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
log.AddFilter("file", level, flw)
log.Info("Redirectoring logging to %s", logFile)
}
func SetupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
}
log.Global = make(map[string]*log.Filter)
Global = log.Global
if logFile == "stdout" || logFile == "" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stdout", level, flw)
} else if logFile == "stderr" || logFile == "" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stderr", level, flw)
} else {
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
log.AddFilter("file", level, flw)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
}
Global.Info("Redirectoring logging to %s %s", logFile, level)
}
func setLogOutput() {
_, err := os.OpenFile(tywa.LOG_FILE, os.O_RDWR, 0666)
if err != nil {
fmt.Println("Unable to open log file. Reason: ", err)
} else {
log.AddFilter("file", log.FINE, log.NewFileLogWriter(tywa.LOG_FILE, false))
}
}
func initLogger() {
logger = make(log4go.Logger)
logger.AddFilter("stdout", log4go.INFO, log4go.NewConsoleLogWriter())
if logFileName := configCommon("log", INFO); logFileName != "" {
logger.AddFilter("file", log4go.INFO, log4go.NewFileLogWriter(logFileName, false).SetFormat("[%D %T][%L]%M - %S"))
}
logger.Info("log module initialized")
}
func NewAgent(opts Options) *Agent {
log := l4g.NewLogger()
log.AddFilter("file", l4g.DEBUG, l4g.NewFileLogWriter("agent.log", false))
return &Agent{
opts: opts,
exitChan: make(chan bool),
startTime: time.Now(),
clients: make(map[*Client]struct{}, opts.MaxOnlineNum),
Logger: log,
}
}
func main() {
// Get a new logger instance
log := l4g.NewLogger()
// Create a default logger that is logging messages of FINE or higher
log.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter(filename, false))
log.Close()
/* Can also specify manually via the following: (these are the defaults) */
flw := l4g.NewFileLogWriter(filename, false)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(false)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(false)
log.AddFilter("file", l4g.FINE, flw)
// Log some experimental messages
log.Finest("Everything is created now (notice that I will not be printing to the file)")
log.Info("The time is now: %s", time.Now().Format("15:04:05 MST 2006/01/02"))
log.Critical("Time to close out!")
// Close the log
log.Close()
// Print what was logged to the file (yes, I know I'm skipping error checking)
fd, _ := os.Open(filename)
in := bufio.NewReader(fd)
fmt.Print("Messages logged to file were: (line numbers not included)\n")
for lineno := 1; ; lineno++ {
line, err := in.ReadString('\n')
if err == io.EOF {
break
}
fmt.Printf("%3d:\t%s", lineno, line)
}
fd.Close()
// Remove the file so it's not lying around
os.Remove(filename)
}
func InitLogger(filename string, logFormat string) {
log = make(l4g.Logger)
flw := l4g.NewFileLogWriter(filename, false)
flw.SetFormat(logFormat)
flw.SetRotate(false)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(false)
log.AddFilter("file", l4g.INFO, flw)
//log.LoadConfiguration(filename)
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "fine":
level = log.FINE
case "debug":
level = log.DEBUG
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
default:
log.Error("Unknown log level %s. Defaulting to DEBUG", loggingLevel)
}
log.Global = make(map[string]*log.Filter)
facility, ok := GetSysLogFacility(logFile)
if ok {
flw, err := NewSysLogWriter(facility)
if err != nil {
fmt.Fprintf(os.Stderr, "NewSysLogWriter: %s\n", err.Error())
return
}
log.AddFilter("syslog", level, flw)
} else if logFile == "stdout" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stdout", level, flw)
} else {
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
if flw == nil {
os.Exit(1)
}
log.AddFilter("file", level, flw)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
}
log.Info("Redirectoring logging to %s", logFile)
}
func LogTo(target string, verbosity string) {
var writer log.LogWriter = nil
switch target {
case "stdout":
writer = log.NewConsoleLogWriter()
case "none":
// no logging
default:
writer = log.NewFileLogWriter(target, true)
}
if writer != nil {
setupVerbosity(writer, verbosity)
}
}
func LogTo(target string) {
var writer log.LogWriter = nil
switch target {
case "stdout":
writer = log.NewConsoleLogWriter()
case "none":
// no logging
default:
writer = log.NewFileLogWriter(target, true)
}
if writer != nil {
root.AddFilter("log", log.TRACE, writer)
}
}
func main() {
log4go.AddFilter("file", log4go.FINEST, log4go.NewFileLogWriter("debug.log", true))
defer func() {
py.NewLock()
py.Finalize()
}()
if err := termbox.Init(); err != nil {
log4go.Exit(err)
}
var t tbfe
t.dorender = make(chan bool, render_chan_len)
t.layout = make(map[*backend.View]layout)
go t.renderthread()
t.loop()
}
func configureLog(s *model.LogSettings) {
l4g.Close()
if s.EnableConsole {
level := l4g.DEBUG
if s.ConsoleLevel == "INFO" {
level = l4g.INFO
} else if s.ConsoleLevel == "WARN" {
level = l4g.WARNING
} else if s.ConsoleLevel == "ERROR" {
level = l4g.ERROR
}
l4g.AddFilter("stdout", level, l4g.NewConsoleLogWriter())
}
if s.EnableFile {
var fileFormat = s.FileFormat
if fileFormat == "" {
fileFormat = "[%D %T] [%L] %M"
}
level := l4g.DEBUG
if s.FileLevel == "INFO" {
level = l4g.INFO
} else if s.FileLevel == "WARN" {
level = l4g.WARNING
} else if s.FileLevel == "ERROR" {
level = l4g.ERROR
}
flw := l4g.NewFileLogWriter(GetLogFileLocation(s.FileLocation), false)
flw.SetFormat(fileFormat)
flw.SetRotate(true)
flw.SetRotateLines(LOG_ROTATE_SIZE)
l4g.AddFilter("file", level, flw)
}
}
func setup_logger() {
filename := "/var/log/ranger/ranger.log"
// Create a default logger that is logging messages of FINE or higher to filename, no rotation
// log.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter(filename, false))
// =OR= Can also specify manually via the following: (these are the defaults, this is equivalent to above)
flw := l4g.NewFileLogWriter(filename, false)
if flw == nil {
fmt.Printf("No permission to write to %s, going to switch to stdout only\n", filename)
} else {
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(false)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
l4g.AddFilter("file", l4g.DEBUG, flw)
l4g.AddFilter("stdout", l4g.ERROR, l4g.NewConsoleLogWriter())
}
}
func main() {
screen.FillRect(nil, bgcolor)
go ui_main()
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
flw := l4g.NewFileLogWriter("/tmp/golog.log", false)
flw.SetFormat("[%D %T] [%L] GOMANAGER : %M ")
flw.SetRotate(false)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(false)
l4g.AddFilter("file", l4g.FINE, flw)
l4g.Info(" --- START GOMANAGER ---")
writeSDLstr(" --- START GOMANAGER ---")
c, err := NewConsumer(*uri, *exchange, *exchangeType, *queue, *bindingKey, *consumerTag)
if err != nil {
log.Fatalf("%s", err)
}
if *lifetime > 0 {
l4g.Info("running for %s", *lifetime)
time.Sleep(*lifetime)
} else {
l4g.Info("running forever")
writeSDLstr("running forever")
select {}
}
l4g.Info("shutting down")
if err := c.Shutdown(); err != nil {
log.Fatalf("error during shutdown: %s", err)
}
}
func LogTo(target string, level_name string) {
var writer log.LogWriter = nil
switch target {
case "stdout":
writer = log.NewConsoleLogWriter()
case "none":
// no logging
default:
writer = log.NewFileLogWriter(target, true)
}
if writer != nil {
var level = log.DEBUG
switch level_name {
case "FINEST":
level = log.FINEST
case "FINE":
level = log.FINE
case "DEBUG":
level = log.DEBUG
case "TRACE":
level = log.TRACE
case "INFO":
level = log.INFO
case "WARNING":
level = log.WARNING
case "ERROR":
level = log.ERROR
case "CRITICAL":
level = log.CRITICAL
default:
level = log.DEBUG
}
root.AddFilter("log", level, writer)
}
}
func configureLog(s LogSettings) {
l4g.Close()
if s.ConsoleEnable {
level := l4g.DEBUG
if s.ConsoleLevel == "INFO" {
level = l4g.INFO
} else if s.ConsoleLevel == "ERROR" {
level = l4g.ERROR
}
l4g.AddFilter("stdout", level, l4g.NewConsoleLogWriter())
}
if s.FileEnable {
if s.FileFormat == "" {
s.FileFormat = "[%D %T] [%L] %M"
}
if s.FileLocation == "" {
s.FileLocation = FindDir("logs") + "mattermost.log"
}
level := l4g.DEBUG
if s.FileLevel == "INFO" {
level = l4g.INFO
} else if s.FileLevel == "ERROR" {
level = l4g.ERROR
}
flw := l4g.NewFileLogWriter(s.FileLocation, false)
flw.SetFormat(s.FileFormat)
flw.SetRotate(true)
flw.SetRotateLines(100000)
l4g.AddFilter("file", level, flw)
}
}
//init for logger
func InitLogger(logFilename string) log4go.Logger {
//var filenameOnly string = GetCurFilename()
//var logFilename string = filenameOnly + ".log";
//gLogger = log4go.NewLogger()
//gLogger = make(log4go.Logger)
//for console
//gLogger.AddFilter("stdout", log4go.INFO, log4go.NewConsoleLogWriter())
gLogger = log4go.NewDefaultLogger(log4go.INFO)
//for log file
if _, err := os.Stat(logFilename); err == nil {
//fmt.Printf("found old log file %s, now remove it\n", logFilename)
os.Remove(logFilename)
}
//gLogger.AddFilter("logfile", log4go.FINEST, log4go.NewFileLogWriter(logFilename, true))
//gLogger.AddFilter("logfile", log4go.FINEST, log4go.NewFileLogWriter(logFilename, false))
gLogger.AddFilter("log", log4go.FINEST, log4go.NewFileLogWriter(logFilename, false))
gLogger.Debug("Current time is : %s", time.Now().Format("15:04:05 MST 2006/01/02"))
return gLogger
}
func NewLogger(config *LogConfig) Logger {
lvl := log4go.DEBUG
switch config.Level {
case "finest":
lvl = log4go.FINEST
case "fine":
lvl = log4go.FINE
case "trace":
lvl = log4go.TRACE
case "info":
lvl = log4go.INFO
case "warning":
lvl = log4go.WARNING
case "error":
lvl = log4go.ERROR
case "critical":
lvl = log4go.CRITICAL
}
log := make(log4go.Logger)
log.AddFilter("stdout", lvl, log4go.NewConsoleLogWriter())
if config.File != "" {
file := log4go.NewFileLogWriter(config.File, config.Rotate)
if config.Format != "" {
file.SetFormat(config.Format)
}
log.AddFilter("file", lvl, file)
}
return &log
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "TRACE":
level = log.TRACE
case "DEBUG":
level = log.DEBUG
case "INFO":
level = log.INFO
case "WARN":
level = log.WARNING
case "ERROR":
level = log.ERROR
}
log.Global = make(map[string]*log.Filter)
if logFile == "stdout" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stdout", level, flw)
} else {
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
log.AddFilter("file", level, flw)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
}
log.Info("Redirectoring logging to %s", logFile)
}
func init() {
runtime.GOMAXPROCS(runtime.NumCPU())
logger = make(log4go.Logger)
flw := log4go.NewFileLogWriter("./log/http.log", true)
flw.SetFormat("[%D %T] [%L] %M")
flw.SetRotateSize(1024 * 1024 * 1024)
logger.AddFilter("file", log4go.INFO, flw)
var err error
conf, err = ReadConfig("./nethermes.json")
if err != nil {
logger.Info("Could not read nethermes.json")
}
logger.Info("Using following configuration: %+v", conf)
idRegex := fmt.Sprintf("[%s]{%d}", conf.KeyCharset, conf.KeyLength)
rand.Seed(time.Now().Unix() + 3301)
r := mux.NewRouter()
s := r.Methods("GET").Subrouter()
s.HandleFunc("/", IndexHandler)
s.HandleFunc("/status/{id:"+idRegex+"}", StatusHandler)
s.HandleFunc("/download/{id:"+idRegex+"}", DownloadHandler)
s.Handle("/{_:(.*)}", http.FileServer(http.Dir("./htdocs")))
s = r.Methods("POST").Subrouter()
s.HandleFunc("/upload/{id:"+idRegex+"}", UploadHandler)
http.Handle("/", r)
indextemplate, err = template.ParseFiles("./index.html")
if err != nil {
logger.Critical("Parse template: ", err)
os.Exit(1)
}
go CleanOld()
}
// checkpoing deamon go
func StartCheckpointDeamon() {
cpLog.AddFilter("log", log.FINE, log.NewFileLogWriter(CP_FILE_NAME, false))
// t := newDeamonTimer(Conf.CheckPointTimeout)
go func() {
for {
select {
case cp := <-checkpoint:
writecp(cp, fmt.Sprintf("exceed threshold %d", Conf.CheckPointThreshold))
// t.reset()
case <-time.After(Conf.CheckPointTimeout):
seconds := int32(time.Now().Unix())
writecp(int64(seconds)<<32, fmt.Sprintf("timeout %d millisecond", Conf.CheckPointTimeout/(1000*1000)))
// t.reset()
}
}
}()
}
func main() {
log := l4g.NewDefaultLogger(l4g.DEBUG)
//输出到控制台,级别为DEBUG
log.AddFilter("stdout", l4g.DEBUG, l4g.NewConsoleLogWriter())
//logs文件夹需要运行前创建，否则异常
//输出到文件,级别为DEBUG,文件名为test.log,每次追加该原文件
log.AddFilter("log", l4g.DEBUG, l4g.NewFileLogWriter("logs/test.log", false))
//使用加载配置文件,类似与java的log4j.propertites
//l4g.LoadConfiguration("log4go.xml")
//l4g.Info("xxx")
//log.Error("yyy")
log.Debug("the time is now :%s -- %s", "213", "sad")
//程序退出太快是来不及写log的
time.Sleep(1000 * time.Millisecond)
//log.Write2Exit()
//注:如果不是一直运行的程序,请加上这句话,否则主线程结束后,也不会输出和log到日志文件
defer log.Close()
}
func NewFileLogWriter(fname string, rotate bool) *fileLogWriter {
ret := &fileLogWriter{
writer: log4go.NewFileLogWriter(fname, rotate),
}
return ret
}
func init() {
keyLog.AddFilter("log", log.FINE, log.NewFileLogWriter("keys-test", false))
}