func initLogs(ctx *cli.Context) { logger := log.StandardLogger() if ctx.GlobalBool("verbose") { logger.Level = log.DebugLevel } var ( isTerm = log.IsTerminal() json = ctx.GlobalBool("json") useColors = isTerm && !json ) if ctx.GlobalIsSet("colors") { useColors = ctx.GlobalBool("colors") } color.NoColor = !useColors if json { logger.Formatter = &log.JSONFormatter{} } else { formatter := &textformatter.TextFormatter{} formatter.DisableColors = !useColors logger.Formatter = formatter } }
func (f *LogFormatter) Format(entry *logrus.Entry) ([]byte, error) { b := &bytes.Buffer{} // Start by printing the time now := time.Now() fmt.Fprintf(b, "%s ", now.Format("2006-01-02 15:04:05")) // Upper case the log level levelText := strings.ToUpper(entry.Data["level"].(string)) // Print the log level, but toggle the color if logrus.IsTerminal() { levelColor := green if entry.Data["level"] == "debug" { levelColor = blue } else if entry.Data["level"] == "warning" { levelColor = yellow } else if entry.Data["level"] == "error" || entry.Data["level"] == "fatal" || entry.Data["level"] == "panic" { levelColor = red } fmt.Fprintf(b, "\x1b[%dm[%-5s]\x1b[0m ", levelColor, levelText) } else { fmt.Fprintf(b, "[%-5s] ", levelText) } // Now print the message fmt.Fprintf(b, "%s ", entry.Data["msg"]) // Print any extra data. By default, the data map has 3 // elements. if len(entry.Data) > 3 { keys := make([]string, 0) for key, value := range entry.Data { if key != "time" && key != "level" && key != "msg" { if _, ok := value.(string); ok { keys = append(keys, fmt.Sprintf("%v: %s", key, value)) } else { keys = append(keys, fmt.Sprintf("%v: %v", key, value)) } } } fmt.Fprintf(b, "(%s)", strings.Join(keys, " ")) } b.WriteByte('\n') return b.Bytes(), nil }
func main() { flag.BoolVar(&debug, "debug", false, "") flag.StringVar(&pathToConfig, "c", "", "") flag.Usage = func() { fmt.Println(usage) os.Exit(0) } flag.Parse() if log.IsTerminal() { log.SetFormatter(&log.TextFormatter{ FullTimestamp: true, TimestampFormat: "2006-01-02 15:04:05 MST", }) } else { log.SetFormatter(&log.JSONFormatter{ TimestampFormat: "2006-01-02 15:04:05 MST", }) } config, err := common.ReadConfig(pathToConfig) if err != nil { log.Fatalf("Error reading configuration file: %v", err) } if debug { log.SetLevel(log.DebugLevel) } else { log.SetLevel(config.LogLevel()) } app := app.New(config) if debug { app.SetDebugMode() } app.Run() }
func initLogs(ctx *cli.Context) { logger := log.StandardLogger() if ctx.GlobalBool("verbose") { logger.Level = log.DebugLevel } else if ctx.Bool("print") && ctx.GlobalString("log") == "" { logger.Level = log.ErrorLevel } var ( err error isTerm = log.IsTerminal() logFile = ctx.GlobalString("log") logExt = path.Ext(logFile) json = ctx.GlobalBool("json") || logExt == ".json" useColors = isTerm && !json && logFile == "" ) if ctx.GlobalIsSet("colors") { useColors = ctx.GlobalBool("colors") } if logFile != "" { if logFile, err = toAbsolutePath(logFile, false); err != nil { log.Fatal(err) } if logger.Out, err = os.OpenFile(logFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644); err != nil { log.Fatalf("Initializing log: Cannot initialize log file %s due to error %s", logFile, err) } log.Debugf("Initializing log: Successfuly started loggin to '%s'", logFile) } if json { logger.Formatter = &log.JSONFormatter{} } else { formatter := &textformatter.TextFormatter{} formatter.DisableColors = !useColors logger.Formatter = formatter } }
func init() { baseTimestamp = time.Now() isTerminal = logrus.IsTerminal() }
func startDaemon() { var out io.Writer = os.Stdout if !log.IsTerminal() { logFile, logFileErr := util.LogFile("rexray.log") failOnError(logFileErr) out = io.MultiWriter(os.Stdout, logFile) } log.SetOutput(out) fmt.Fprintf(out, "%s\n", rexRayLogoASCII) util.PrintVersion(out) fmt.Fprintln(out) var success []byte var failure []byte var conn net.Conn if !fg { success = []byte{0} failure = []byte{1} var dialErr error log.Printf("dialing %s", client) conn, dialErr = net.Dial("unix", client) if dialErr != nil { panic(dialErr) } } writePidErr := util.WritePidFile(-1) if writePidErr != nil { if conn != nil { conn.Write(failure) } panic(writePidErr) } defer func() { r := recover() os.Remove(util.PidFilePath()) if r != nil { panic(r) } }() log.Printf("created pid file, pid=%d", os.Getpid()) init := make(chan error) sigc := make(chan os.Signal, 1) stop := make(chan os.Signal) signal.Notify(sigc, syscall.SIGKILL, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT) go func() { rrdaemon.Start(r.Config.Host, init, stop) }() var initErrors []error for initErr := range init { initErrors = append(initErrors, initErr) log.Println(initErr) } if conn != nil { if len(initErrors) == 0 { conn.Write(success) } else { conn.Write(failure) } conn.Close() } if len(initErrors) > 0 { return } sigv := <-sigc log.Printf("received shutdown signal %v", sigv) stop <- sigv }
func init() { isTerminal = logrus.IsTerminal() }
func IsTerminal() bool { return logrus.IsTerminal() }
*/ package build import ( "bytes" "fmt" log "github.com/Sirupsen/logrus" "runtime" ) type containerFormatter struct { isColored bool } var isTerminal = log.IsTerminal() // NewColoredContainerFormatter Returns Formatter that makes your messages outputed without any log-related data. // Also, this formatter will make all messages colored (RED for now). // Usefull when you want all stderr messages from container to become more noticible func NewColoredContainerFormatter() log.Formatter { return &containerFormatter{ isColored: true, } } // NewMonochromeContainerFormatter Returns Formatter that makes your messages outputed without any log-related data. func NewMonochromeContainerFormatter() log.Formatter { return &containerFormatter{ isColored: false, }
func isTerminal() bool { return log.IsTerminal() }
package log import ( "bytes" "fmt" "runtime" "time" "github.com/Sirupsen/logrus" "github.com/mgutz/ansi" ) var isTerminal = logrus.IsTerminal() // PrettyFormatter is a formatter that meets the logrus.Formatter interface type PrettyFormatter struct{} // Format formats a logrus.Entry into an array of bytes func (f *PrettyFormatter) Format(entry *logrus.Entry) ([]byte, error) { b := &bytes.Buffer{} isColored := isTerminal && (runtime.GOOS != "windows") if isColored { printColored(b, entry) } else { printUncolored(b, entry) } b.WriteByte('\n') return b.Bytes(), nil } func getLevelString(level logrus.Level) string {