func getConfig() (*types.Config, error) { app.Validate(validateParams) kingpin.HelpFlag.Short('h') app.Flag("version", "Print application version and exit").PreAction(printVersion).Short('v').Bool() kingpin.MustParse(app.Parse(os.Args[1:])) c := &types.Config{ Consul: *consul, Marathon: *marathon, ResyncInterval: *resyncInterval, DryRun: *enableDryRun, } // Setup the logging. level, err := log.ParseLevel(*logLevel) if err != nil { return nil, err } log.SetFormatter(&prefixed.TextFormatter{ ForceColors: *forceColors, }) log.SetLevel(level) if *enableSyslog { hook, err := logrusSyslog.NewSyslogHook("", "", syslog.LOG_DEBUG, app.Name) if err != nil { return nil, err } log.AddHook(hook) } return c, nil }
func New(config *conf.Log) (Logger, error) { logger := logrus.New() if strings.ToLower(config.Local) == "stderr" { logger.Out = os.Stderr } else if strings.ToLower(config.Local) == "stdout" { logger.Out = os.Stdout } else { file, err := os.OpenFile(config.Local, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644) if err != nil { return nil, err } logger.Out = file } logger.Level = levels[config.Level] if config.Syslog.Protocol != "" { level := syslogLevels[config.Syslog.Level] hook, err := logrus_syslog.NewSyslogHook(config.Syslog.Protocol, config.Syslog.Host, level, config.Syslog.Tag) if err != nil { return nil, err } logger.Hooks.Add(hook) } return logger, nil }
func init() { log.Formatter = new(logrus.TextFormatter) // default hook, err := logrus_syslog.NewSyslogHook("udp", "127.0.0.1:514", syslog.LOG_INFO, "") if err != nil { log.Hooks.Add(hook) } }
func setupSyslog(logger *logrus.Logger) error { hook, err := logrus_syslog.NewSyslogHook("", "", getSyslogPriority(logger.Level), "taskcluster-worker") if err != nil { return err } logger.Hooks.Add(hook) return nil }
func setupSyslogLogging(syslogAddr string, syslogProgramName string) { log.Printf("Logging to syslog addr=[%s], program_name=[%s]", syslogAddr, syslogProgramName) logrusSysLogHook, err := logrus_syslog.NewSyslogHook("udp", syslogAddr, syslog.LOG_INFO, syslogProgramName) if err != nil { log.Fatalf("Failed to add syslog logrus hook - %s", err) } log.AddHook(logrusSysLogHook) }
func initLogger() { once.Do(func() { var ( level syslog.Priority hook *logrus_syslog.SyslogHook ) proto, err := config.Instance().String("syslog", "proto") cli.CheckFatalError(err) addr, err := config.Instance().String("syslog", "addr") cli.CheckFatalError(err) levelName, err := config.Instance().String("syslog", "level") cli.CheckFatalError(err) switch levelName { case "debug": level = syslog.LOG_DEBUG case "info": level = syslog.LOG_INFO case "notice": level = syslog.LOG_NOTICE case "warning": level = syslog.LOG_WARNING case "err": level = syslog.LOG_ERR case "crit": level = syslog.LOG_CRIT case "alert": level = syslog.LOG_ALERT case "emerg": level = syslog.LOG_EMERG default: level = syslog.LOG_WARNING } if len(proto) == 0 || len(addr) == 0 { writer, err := syslog.New(level, "recause") if err != nil { cli.CheckFatalError(err) } hook = &logrus_syslog.SyslogHook{ Writer: writer, } } else { hook, err = logrus_syslog.NewSyslogHook(proto, addr, level, "recause") cli.CheckFatalError(err) } logger = log.New() logger.Hooks.Add(hook) log.SetOutput(logger.Writer()) }) }
// Function Home - that handles a web server request for a page func Home(w http.ResponseWriter, req *http.Request) { io.WriteString(w, "Hello World!") log := logrus.New() hook, err := logrus_syslog.NewSyslogHook("udp", os.Getenv("SYSLOG_SERVER")+":"+os.Getenv("SYSLOG_PORT"), syslog.LOG_INFO, "") if err == nil { log.Hooks.Add(hook) } log.Info(req, "\n") }
func setupSyslog() { hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "pmb") if err == nil { logrus.SetFormatter(&SyslogFormatter{}) // discard all output logrus.SetOutput(ioutil.Discard) logrus.AddHook(hook) } }
func init() { conf := config.GetConfig() if conf == nil { conf = &config.Config{} } // Output to stderr instead of stdout, could also be a file. var output io.Writer switch conf.Log.Output.Path { case "stderr": output = os.Stderr case "stdout": output = os.Stdout default: logrus.Warn("No log output defined, using stderr") output = os.Stderr } log.Out = output // Only log the warning severity or above. level, err := logrus.ParseLevel(conf.Log.Output.Level) if err != nil { logrus.Warn("Cannot parse conf level, default to INFO") } else { log.Level = level } for _, hook := range conf.Log.Hook { switch hook.Type { case "syslog": priority := syslog.LOG_INFO if err != nil { logrus.Errorf("%v is not a valid priority, defaulting to Info", hook.Level) } h, err := logrus_syslog.NewSyslogHook(hook.Protocol, hook.URL, priority, "") if err != nil { logrus.Errorf("Unable to connect to syslog daemon %v:%v", hook.Protocol, hook.URL) } else { log.Hooks.Add(h) } case "logstash": level, err := logrus.ParseLevel(hook.Level) if err != nil { logrus.Warn("Cannot parse conf level, default to INFO") } else { log.Level = level } h, err := logstash_hook.NewLogstashHook(hook.Protocol, hook.URL, "application", level) if err != nil { logrus.Errorf("Unable to connect to logstash at %v:%v", hook.Protocol, hook.URL) } else { log.Hooks.Add(h) } } } }
func NewSyslogHook(options logrus_mate.Options) (hook logrus.Hook, err error) { conf := SyslogHookConfig{} if err = options.ToObject(&conf); err != nil { return } return logrus_syslog.NewSyslogHook( conf.Network, conf.Address, toPriority(conf.Priority), conf.Tag) }
// setLog configure the log func (ld *LogData) setLog() error { logLevel, syslogPriority, err := ld.parseLogLevel() if err != nil { return fmt.Errorf("The logLevel must be one of the following: EMERGENCY, ALERT, CRITICAL, ERROR, WARNING, NOTICE, INFO, DEBUG") } log.SetLevel(logLevel) hook, err := logrus_syslog.NewSyslogHook(ld.Network, ld.Address, syslogPriority, "") if err == nil { log.AddHook(hook) } return nil }
func (app *Application) Configure() error { var err error // Set config if err = app.ReadConfigFile(app.Options.Config); err != nil { return err } // Read config if err = app.BindConfig(&app.Config); err != nil { return err } // Set log level var level = log.InfoLevel if app.Options.Debug { level = log.DebugLevel } else if app.Config.Log.Level != "" { level, err = log.ParseLevel(app.Config.Log.Level) if err != nil { log.Warnf("Failed to parse log level: %v", err) } } log.SetLevel(level) // Set log formatter var formatter = "text" if app.Config.Log.Formatter != "" { formatter = app.Config.Log.Formatter } logFormatter, err := ParseLogFormatter(formatter) if err != nil { return err } log.SetFormatter(logFormatter) // Add DebugLoggerHook if we are in debug mode if log.GetLevel() == log.DebugLevel { log.AddHook(new(DebugLoggerHook)) } // Add syslog if app.Config.Log.SyslogName != "" { syslog_hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, app.Config.Log.SyslogName) if err == nil { log.AddHook(syslog_hook) } else { log.Warnf("Failed to use syslog: %v", err) } } return nil }
func InitLoggers(logToSyslog bool) { if logToSyslog { var err error syslogHook, err = logrus_syslog.NewSyslogHook("", "", syslog.LOG_DEBUG, "") if err != nil { panic("Unable to connect to local syslog daemon") } for _, l := range loggers { l.Hooks.Add(syslogHook) } } }
func initLogging() { // level level, err := logrus.ParseLevel(viper.GetString("log-level")) if err != nil { logrus.WithError(err).Warn(`invalid log level. Defaulting to "info"`) level = logrus.InfoLevel } logrus.SetLevel(level) // format switch viper.GetString("log-format") { case "text": logrus.SetFormatter(new(logrus.TextFormatter)) case "json": logrus.SetFormatter(new(logrus.JSONFormatter)) default: logrus.SetFormatter(new(logrus.TextFormatter)) logrus.WithField("format", viper.GetString("log-format")).Warn(`invalid log format. Defaulting to "text"`) } // output dest, err := url.Parse(viper.GetString("log-destination")) if err != nil { logrus.WithError(err).WithField("destination", viper.GetString("log-destination")).Error(`invalid log destination. Defaulting to "stdout:"`) dest.Scheme = "stdout" } switch dest.Scheme { case "stdout": // default, we don't need to do anything case "file": logrus.AddHook(lfshook.NewHook(lfshook.PathMap{ logrus.DebugLevel: dest.Opaque, logrus.InfoLevel: dest.Opaque, logrus.WarnLevel: dest.Opaque, logrus.ErrorLevel: dest.Opaque, logrus.FatalLevel: dest.Opaque, })) case "journald": journalhook.Enable() case "syslog": hook, err := logrus_syslog.NewSyslogHook(dest.Fragment, dest.Host, syslog.LOG_DEBUG, dest.User.String()) if err != nil { logrus.WithError(err).Error("could not configure syslog hook") } else { logrus.AddHook(hook) } default: logrus.WithField("destination", viper.GetString("log-destination")).Warn(`invalid log destination. Defaulting to "stdout:"`) } }
// init inits the auditor logger func (b *basicAuditor) init() error { if b.settings == nil { return fmt.Errorf("Settings is not defeined") } if b.logger != nil { return nil } b.logger = logrus.New() b.logger.Formatter = &logrus.JSONFormatter{} switch b.settings.LogHook { case AuditHookSyslog: { hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_ERR, "authz") if err != nil { return err } b.logger.Hooks.Add(hook) } case AuditHookFile: { logPath := b.settings.LogPath if logPath == "" { logrus.Infof("Using default log file path '%s'", logPath) logPath = defaultAuditLogPath } os.MkdirAll(path.Dir(logPath), 0700) f, err := os.OpenFile(logPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0750) if err != nil { return err } b.logger.Out = f } case AuditHookStdout: { // Default - stdout } default: return fmt.Errorf("Wrong log hook value '%s'", b.settings.LogHook) } return nil }
func pickHook(out logoutput) log.Hook { switch out { case sysLog: hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_DAEMON, "awslogs") if err != nil { log.Fatal("Unable to connect to local syslog daemon") } return hook case stdOut: return &writerHook{out: os.Stdout} case stdErr: return &writerHook{out: os.Stderr} case null: return &writerHook{out: ioutil.Discard} default: return &writerHook{out: os.Stderr} } }
func main() { flag.Parse() if *printVersion { fmt.Printf("%s\n", version) os.Exit(0) } d := new(daemon.Daemon) if *debug { log.SetLevel(log.DebugLevel) } if *logToSyslog { hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "") if err == nil { log.AddHook(hook) } } d.Debug = *debug d.ConfigFile = *f os.Exit(d.Run(*oneshot, *noop)) }
// Add the syslog hook to the logger. This is better than adding it directly, // for the reasons described in the loggingHookType comments. func (l *Logger) AddSyslogHook() error { hook := loggingHookType{} hook.data = &loggingHookData{} hook.data.syslogLogger = logrus.New() hook.data.syslogLogger.Formatter = &logrus.TextFormatter{ DisableColors: true, DisableTimestamp: true, } var err error hook.data.syslogHook, err = logrus_syslog.NewSyslogHook("", "", syslog.LOG_DEBUG, "mender") if err != nil { return err } l.loggingHook = hook l.logHooks.Add(hook) return nil }
func (lcfg *LogConfig) Load() (err error) { // Set log level var level = log.InfoLevel if lcfg.Level != "" { level, err = log.ParseLevel(lcfg.Level) if err != nil { log.Warnf("Failed to parse log level: %v", err) } } log.SetLevel(level) // Set log formatter var formatter = "text" if lcfg.Formatter != "" { formatter = lcfg.Formatter } logFormatter, err := ParseLogFormatter(formatter) if err != nil { return err } log.SetFormatter(logFormatter) // Add DebugLoggerHook if we are in debug mode if log.GetLevel() == log.DebugLevel { log.AddHook(new(DebugLoggerHook)) } // Add syslog if lcfg.SyslogName != "" { syslog_hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, lcfg.SyslogName) if err == nil { log.AddHook(syslog_hook) } else { log.Warnf("Failed to use syslog: %v", err) } } return nil }
func (s *Service) Start() error { // if .LogFormatter is set, it'll be used in log.SetFormatter() and .Log will be ignored. if s.options.LogFormatter != nil { log.SetFormatter(s.options.LogFormatter) } else { switch s.options.Log { case "console": { log.SetFormatter(&log.TextFormatter{}) } case "json": { log.SetFormatter(&log.JSONFormatter{}) } case "syslog": { hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "") if err == nil { log.SetFormatter(&log.TextFormatter{DisableColors: true}) log.AddHook(hook) } else { setFallbackLogFormatter(s.options) } } case "logstash": { log.SetFormatter(&logrus_logstash.LogstashFormatter{Type: "logs"}) } default: setFallbackLogFormatter(s.options) } } log.SetOutput(os.Stdout) log.SetLevel(s.options.LogSeverity.S) log.Infof("Service starts with options: %#v", s.options) if s.options.PidPath != "" { ioutil.WriteFile(s.options.PidPath, []byte(fmt.Sprint(os.Getpid())), 0644) } if s.options.MetricsClient != nil { s.metricsClient = s.options.MetricsClient } else if s.options.StatsdAddr != "" { var err error s.metricsClient, err = metrics.NewWithOptions(s.options.StatsdAddr, s.options.StatsdPrefix, metrics.Options{UseBuffering: true}) if err != nil { return err } } apiFile, muxFiles, err := s.getFiles() if err != nil { return err } if err := s.newEngine(); err != nil { return err } s.stapler = stapler.New() s.supervisor = supervisor.New( s.newProxy, s.ng, s.errorC, supervisor.Options{Files: muxFiles}) // Tells configurator to perform initial proxy configuration and start watching changes if err := s.supervisor.Start(); err != nil { return err } if err := s.initApi(); err != nil { return err } go func() { s.errorC <- s.startApi(apiFile) }() if s.metricsClient != nil { go s.reportSystemMetrics() } signal.Notify(s.sigC, os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGUSR2, syscall.SIGCHLD) // Block until a signal is received or we got an error for { select { case signal := <-s.sigC: switch signal { case syscall.SIGTERM, syscall.SIGINT: log.Infof("Got signal '%s', shutting down gracefully", signal) s.supervisor.Stop(true) log.Infof("All servers stopped") return nil case syscall.SIGKILL: log.Infof("Got signal '%s', exiting now without waiting", signal) s.supervisor.Stop(false) return nil case syscall.SIGUSR2: log.Infof("Got signal '%s', forking a new self", signal) if err := s.startChild(); err != nil { log.Infof("Failed to start self: %s", err) } else { log.Infof("Successfully started self") } case syscall.SIGCHLD: log.Warningf("Child exited, got '%s', collecting status", signal) var wait syscall.WaitStatus syscall.Wait4(-1, &wait, syscall.WNOHANG, nil) log.Warningf("Collected exit status from child") default: log.Infof("Ignoring '%s'", signal) } case err := <-s.errorC: log.Infof("Got request to shutdown with error: %s", err) return err } } }
var formatter logrus.Formatter = new(logrus.JSONFormatter) switch lg.config.GetStringWithDefault("log.console.format", "json") { case "text": formatter = new(logrus.TextFormatter) case "logstash": formatter = &logrus_logstash.LogstashFormatter{Type: lg.config.Product} } lg.Formatter = formatter }, "log.syslog": func(lg *Log) { cfg := lg.config t := cfg.GetString("log.syslog.transport") s := cfg.GetString("log.syslog.server") l := lg.parseSyslog(cfg.GetString("log.hooks.syslog.level")) tag := cfg.Product hook, err := logrus_syslog.NewSyslogHook(t, s, l, tag) if err != nil { log.Fatalf("Log: cannot add syslog hook: %s", err) } lg.Hooks.Add(hook) }, } func (lg *Log) parseSyslog(level string) syslog.Priority { switch level { case "panic": return syslog.LOG_EMERG case "fatal": return syslog.LOG_CRIT case "error": return syslog.LOG_ERR
func main() { var err error readConfig(true) err = validateConfig() if err != nil { fmt.Printf("\n%s\n\n", err) flag.Usage() os.Exit(1) } if Config.ShowVersion { fmt.Printf("statsdaemon v%s (built w/%s)\n", VERSION, runtime.Version()) os.Exit(0) } if Config.PrintConfig { out, _ := yaml.Marshal(Config) fmt.Printf("# Default config file in YAML based on config options\n%s", string(out)) os.Exit(0) } log.SetLevel(Config.InternalLogLevel) if Config.LogName == "stdout" { log.SetOutput(os.Stdout) } else { if len(Config.LogName) > 0 { logFile, err := os.OpenFile(Config.LogName, os.O_WRONLY|os.O_CREATE, 0640) if err != nil { fmt.Printf("Error opennig log file: %s\n", err) os.Exit(1) } log.SetFormatter(&log.TextFormatter{DisableColors: true}) log.SetOutput(logFile) defer logFile.Close() } } if Config.LogToSyslog { // set syslog syslogNetwork := "" if len(Config.SyslogUDPAddress) > 0 { syslogNetwork = "udp" } hook, err := logrus_syslog.NewSyslogHook(syslogNetwork, Config.SyslogUDPAddress, syslog.LOG_DEBUG|syslog.LOG_LOCAL3, "statsdaemon") if err != nil { fmt.Printf("Unable to connect to syslog daemon: %s\n", err) } else { log.AddHook(hook) log.SetFormatter(&log.JSONFormatter{}) } } if Config.LogName == "" { log.SetOutput(ioutil.Discard) } // if Config.LogLevel == "debug" { // go func() { // log.Println(http.ListenAndServe(":8082", nil)) // }() // } // Stat Stat.Interval = Config.FlushInterval signalchan = make(chan os.Signal, 1) signal.Notify(signalchan, syscall.SIGTERM, syscall.SIGQUIT) dbHandle, err = bolt.Open(Config.StoreDb, 0644, &bolt.Options{Timeout: 1 * time.Second}) if err != nil { log.WithFields(log.Fields{ "in": "main", "after": "Open", "ctx": "Bolt DB open", }).Fatalf("%s", err) } // dbHandle.NoSync = true defer dbHandle.Close() go udpListener() if Config.TCPServiceAddress != "" { go tcpListener() } monitor() }