Beispiel #1
0
//NewLogger creates a
//logger  for logrus
func NewLogger(cfg configFile) *log.Logger {
	//This creates new logger
	Log = log.New()
	Log.Formatter = new(log.JSONFormatter)
	Log.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
		log.InfoLevel:  cfg.Log.Path,
		log.ErrorLevel: cfg.Log.Path,
		log.DebugLevel: cfg.Log.Path,
	}))
	Log.Hooks.Add(&metricsHook{
		metrics,
	})
	client, err := elastic.NewClient(
		elastic.SetURL(cfg.Elastic.URL),
		elastic.SetBasicAuth(cfg.Elastic.Username, cfg.Elastic.Password))
	if err != nil {
		log.Error(err)
	} else {
		hook, err := elogrus.NewElasticHook(client, cfg.Server.Host, log.DebugLevel, "goplag")
		if err != nil {
			log.Error(err)
		} else {
			Log.Hooks.Add(hook)
		}

	}

	return Log
}
Beispiel #2
0
func setupFileLogging(logFile string) {
	log.Printf("Logging to file=[%s]", logFile)
	logrusFileHook := lfshook.NewHook(lfshook.PathMap{
		log.InfoLevel: logFile, log.WarnLevel: logFile, log.ErrorLevel: logFile, log.FatalLevel: logFile, log.PanicLevel: logFile,
	})
	log.AddHook(logrusFileHook)
}
Beispiel #3
0
func AddLogFile(filename string) {
	log.AddHook(lfshook.NewHook(lfshook.PathMap{
		log.DebugLevel: filename,
		log.InfoLevel:  filename,
		log.WarnLevel:  filename,
		log.ErrorLevel: filename,
		log.FatalLevel: filename,
		log.PanicLevel: filename,
	}))
}
Beispiel #4
0
Datei: log.go Projekt: ahjdzx/dis
func SetLogFile(logFile string) {
	hook := lfshook.NewHook(lfshook.PathMap{
		logrus.DebugLevel: logFile,
		logrus.InfoLevel:  logFile,
		logrus.WarnLevel:  logFile,
		logrus.ErrorLevel: logFile,
		logrus.FatalLevel: logFile,
	})
	logger.Hooks.Add(hook)
}
Beispiel #5
0
func TestSMPPTranceiver(t *testing.T) {
	// формируем параметры авторизации
	bindParams := smpp.Params{
		smpp.SYSTEM_TYPE: "SMPP",
		smpp.SYSTEM_ID:   "Zultys",
		smpp.PASSWORD:    "******",
	}
	logrus.SetLevel(logrus.DebugLevel)
	logrus.AddHook(lfshook.NewHook(lfshook.PathMap{
		logrus.InfoLevel:  "info.log",
		logrus.ErrorLevel: "error.log",
		logrus.DebugLevel: "debug.log",
		logrus.WarnLevel:  "warning.log",
	}))
	logrus.SetFormatter(new(prefixed.TextFormatter))
	Logger := logrus.StandardLogger().WithField("smpp", addr)
	trx, err := NewTransceiver(addr, 0, bindParams, Logger)
	if err != nil {
		Logger.WithError(err).Error("Connect error")
		t.Fatal(err)
	}
	defer trx.Close()
	receive := make(chan interface{}, 10)   // канал для получения SMS
	status := make(chan Status, 10)         // канал для получения статусов доставки
	response := make(chan SendResponse, 10) // канал для получения подтверждений отправки
	go func() {
		for {
			select {
			case msg := <-receive:
				Logger.Debugln("Receive:", msg)
			case msg := <-status:
				Logger.Debugln("Status:", msg)
			case msg := <-response:
				Logger.Debugln("Response:", msg)
			}
		}
	}()
	go trx.reading(receive) // запускаем получение данных с сервера
	for _, text := range texts {
		time.Sleep(time.Second * 10)
		sms := &SendMessage{
			From: from,
			To:   to2,
			Text: text,
		}
		err := trx.Send(sms)
		if err != nil {
			Logger.WithError(err).Error("Send error")
			t.Error(err)
		}
		Logger.WithField("seqs", sms.Seq).Info("Sended")
	}

	time.Sleep(time.Minute * 5)
}
Beispiel #6
0
//InitLog system
func InitLog() {
	log.SetOutput(os.Stderr)
	log.SetLevel(log.WarnLevel)
	Log = log.New()
	LogWriter = Log.Writer()
	Log.Formatter = new(log.JSONFormatter)
	Log.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
		log.InfoLevel:  "log/info.log",
		log.ErrorLevel: "log/error.log",
	}))
}
Beispiel #7
0
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:"`)
	}
}
Beispiel #8
0
//InitLog system
func InitLogger() {
	if Log == nil {
		log.SetOutput(os.Stderr)
		log.SetLevel(log.WarnLevel)
		Log = log.New()
		Log.Formatter = new(log.JSONFormatter)
		fmt.Printf("LOADED LOG %s", os.Getenv("MODE"))
		if os.Getenv("MODE") == "production" {
			Log.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
				log.InfoLevel:  "log/info.log",
				log.ErrorLevel: "log/error.log",
			}))
		}
	}
}
Beispiel #9
0
// NewCustomLogger creates logrus
func NewCustomLogger(c config.ServerInfo) *logrus.Entry {
	log := logrus.New()
	log.Formatter = &formatter.TextFormatter{MsgAnsiColor: c.LogMsgAnsiColor}
	log.Out = os.Stderr
	log.Level = logrus.InfoLevel
	if config.Conf.Debug {
		log.Level = logrus.DebugLevel
	}

	// File output
	logDir := "/var/log/vuls"
	if runtime.GOOS == "windows" {
		logDir = filepath.Join(os.Getenv("APPDATA"), "vuls")
	}
	if _, err := os.Stat(logDir); os.IsNotExist(err) {
		if err := os.Mkdir(logDir, 0666); err != nil {
			logrus.Errorf("Failed to create log directory: %s", err)
		}
	}

	whereami := "localhost"
	if 0 < len(c.ServerName) {
		if 0 < len(c.Container.ContainerID) {
			whereami = fmt.Sprintf(
				"%s_%s", c.ServerName, c.Container.Name)
		} else {
			whereami = fmt.Sprintf("%s", c.ServerName)
		}
	}

	if _, err := os.Stat(logDir); err == nil {
		path := filepath.Join(logDir, whereami)
		log.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
			logrus.DebugLevel: path,
			logrus.InfoLevel:  path,
			logrus.WarnLevel:  path,
			logrus.ErrorLevel: path,
			logrus.FatalLevel: path,
			logrus.PanicLevel: path,
		}))
	}

	fields := logrus.Fields{"prefix": whereami}
	return log.WithFields(fields)
}
Beispiel #10
0
// NewLocalParser return local site
func NewLocalParser(owner, contextDir string) (*Parser, error) {
	s, err := local.New(contextDir)
	if err != nil {
		return nil, err
	}

	config, sites, defaultSite := loadConfigAndSites(s)
	s.SourcePath = filepath.Join(s.RootPath, config.Source)
	s.DestinationPath = filepath.Join(s.RootPath, config.Destination)

	warnPath := s.GetSourceKey(PrefixLogs, "warn.log")
	errorPath := s.GetSourceKey(PrefixLogs, "error.log")
	if !s.IsExist(warnPath) {
		s.Write(warnPath, []byte{})
	}
	if !s.IsExist(errorPath) {
		s.Write(errorPath, []byte{})
	}

	cacheFiles := make(map[string][]byte)

	logger := log.New()
	logger.Formatter = new(log.TextFormatter)
	logger.Level = log.WarnLevel
	logger.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
		log.WarnLevel:  warnPath,
		log.ErrorLevel: errorPath,
	}))

	parser := &Parser{
		Owner:      owner,
		Name:       s.Name,
		Path:       s.RootPath,
		Config:     config,
		Sites:      sites,
		Default:    defaultSite,
		Current:    defaultSite,
		cacheFiles: cacheFiles,
		logger:     logger,
	}
	parser.Storage = s

	return parser, nil
}
Beispiel #11
0
// NewCustomLogger creates logrus
func NewCustomLogger(c config.ServerInfo) *logrus.Entry {
	log := logrus.New()
	log.Formatter = &formatter.TextFormatter{MsgAnsiColor: c.LogMsgAnsiColor}
	log.Out = os.Stderr
	log.Level = logrus.InfoLevel
	if config.Conf.Debug {
		log.Level = logrus.DebugLevel
	}

	// File output
	logDir := GetDefaultLogDir()
	if 0 < len(config.Conf.LogDir) {
		logDir = config.Conf.LogDir
	}

	if _, err := os.Stat(logDir); os.IsNotExist(err) {
		if err := os.Mkdir(logDir, 0700); err != nil {
			logrus.Errorf("Failed to create log directory: %s", err)
		}
	}

	whereami := "localhost"
	if 0 < len(c.ServerName) {
		whereami = c.GetServerName()
	}

	if _, err := os.Stat(logDir); err == nil {
		path := filepath.Join(logDir, whereami)
		log.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
			logrus.DebugLevel: path,
			logrus.InfoLevel:  path,
			logrus.WarnLevel:  path,
			logrus.ErrorLevel: path,
			logrus.FatalLevel: path,
			logrus.PanicLevel: path,
		}))
	}

	fields := logrus.Fields{"prefix": whereami}
	return log.WithFields(fields)
}
Beispiel #12
0
func GetLogger(logLevelFilePathMap map[log.Level]string) *log.Logger {
	if _logger != nil {
		return _logger
	}

	//create if not exist
	for _, path := range logLevelFilePathMap {
		if _, err := os.Stat(path); os.IsNotExist(err) {

			file, err := os.Create(path)
			defer file.Close()
			if err != nil {
				fmt.Println(err)
			}
		}
	}

	_logger = log.New()
	//_logger.Formatter = new(log.JSONFormatter)
	_logger.Formatter = new(log.TextFormatter)
	_logger.Hooks.Add(lfshook.NewHook(logLevelFilePathMap))

	return _logger
}
Beispiel #13
0
func setupLogger() {
	logger.Hooks.Add(lfshook.NewHook(lfshook.PathMap{
		logrus.ErrorLevel: config.Logfile,
	}))
}
Beispiel #14
0
func main() {
	authFunc := func(username, password string) bool {
		log.WithFields(log.Fields{"username": username, "password": "******"}).Debug("main::authFunc Authentication requested")
		return true
	}

	logLevel := flag.String("ll", "Info", "Minimum log level. Available values are Debug, Info, Warn, Error")
	azureAccount := flag.String("an", "", "Azure blob storage account name")
	azureKey := flag.String("ak", "", "Azure blob storage account key (either primary or secondary)")
	localFSRoot := flag.String("lfs", "", "Local file system root")

	tlsCertFile := flag.String("crt", "", "TLS certificate file")
	tlsKeyFile := flag.String("key", "", "TLS certificate key file")

	plainCmdPort := flag.Int("plainPort", 21, "Plain FTP port (unencrypted). If you specify a TLS certificate and key encryption you can pass -1 to start a SFTP implicit server only")
	encrCmdPort := flag.Int("tlsPort", 990, "Encrypted FTP port. If you do not specify a TLS certificate this port is ignored. If you specify -1 the implicit SFTP is disabled")

	lowerPort := flag.Int("minPasvPort", 50000, "Lower passive port range")
	higerPort := flag.Int("maxPasvPort", 50100, "Higher passive port range")

	logFileDebug := flag.String("lDebug", "", "Debug level log file")
	logFileInfo := flag.String("lInfo", "", "Info level log file")
	logFileWarn := flag.String("lWarn", "", "Warn level log file")
	logFileError := flag.String("lError", "", "Error level log file")

	flag.Parse()

	if *logFileDebug != "" || *logFileInfo != "" || *logFileWarn != "" || *logFileError != "" {
		log.AddHook(lfshook.NewHook(lfshook.PathMap{
			log.DebugLevel: *logFileDebug,
			log.InfoLevel:  *logFileInfo,
			log.WarnLevel:  *logFileWarn,
			log.ErrorLevel: *logFileError,
		}))
	}

	if (*azureAccount == "" || *azureKey == "") && *localFSRoot == "" {
		log.Error("main::main must specify either a local file system root or a azure account (both name and key) as storage. Check the command line docs for help")
		os.Exit(-1)
	}

	switch strings.ToLower(*logLevel) {
	case "debug":
		log.SetLevel(log.DebugLevel)
	case "info":
		log.SetLevel(log.InfoLevel)
	case "warn":
		log.SetLevel(log.WarnLevel)
	case "error":
		log.SetLevel(log.ErrorLevel)
	default:
		log.WithFields(log.Fields{"logLevel": logLevel}).Error("main::main unsupported log level")
		os.Exit(-1)
	}

	log.WithField("program", os.Args[0]).Info("Program started")

	var fs fs.FileProvider
	var err error

	var cert tls.Certificate
	if *tlsCertFile != "" && *tlsKeyFile != "" {
		cert, err = tls.LoadX509KeyPair(*tlsCertFile, *tlsKeyFile)
		if err != nil {
			panic(err)
		}
	}

	if *azureAccount != "" && *azureKey != "" {
		log.WithFields(log.Fields{"account": *azureAccount}).Info("main::main initializating Azure blob storage backend")
		fs, err = azureFS.New(*azureAccount, *azureKey)
	} else {
		log.WithFields(log.Fields{"localFSRoot": *localFSRoot}).Info("main::main initializating local fs backend")
		fs, err = localFS.New(*localFSRoot)
	}

	if err != nil {
		panic(err)
	}

	// 15 min connection timeout
	timeout, err := time.ParseDuration("15m")
	if err != nil {
		panic(err)
	}

	var srv *ftp.Server
	if *tlsCertFile != "" && *tlsKeyFile != "" {
		if *encrCmdPort == -1 {
			srv = ftp.NewTLS(*plainCmdPort, &cert, timeout, *lowerPort, *higerPort, authFunc, fs)
		} else {
			srv = ftp.New(*plainCmdPort, *encrCmdPort, &cert, timeout, *lowerPort, *higerPort, authFunc, fs)
		}
	} else {
		srv = ftp.NewPlain(*plainCmdPort, nil, timeout, *lowerPort, *higerPort, authFunc, fs)
	}

	srv.Accept()

	signal_chan := make(chan os.Signal, 1)
	var code int
	signal.Notify(signal_chan)
	for {
		s := <-signal_chan
		switch s {
		case syscall.SIGINT:
			log.WithFields(log.Fields{"signal": "SIGINT"}).Warn("main::main " + s.String())
			code = 0
		case syscall.SIGTERM:
			log.WithFields(log.Fields{"signal": "SIGTERM"}).Warn("main::main " + s.String())
			code = 0
		case syscall.SIGPIPE:
			log.WithFields(log.Fields{"signal": "SIGPIPE"}).Warn("main::main " + s.String())
			continue
		default:
			log.Error("main::main Unknown signal (" + s.String() + ")")
			code = 1
		}
		break
	}
	os.Exit(code)
}