Example #1
0
// loadConfiguration loads the configuration of application
func loadConfiguration(app *AppConfig, rdis *RedisConfig, nats *NatsConfig) {
	err := envconfig.Process(ServiceName, app)
	if err != nil {
		log.Panicln(err)
	}
	err = envconfig.Process("redis", rdis)
	if err != nil {
		log.Panicln(err)
	}
	err = envconfig.Process("nats", nats)
	if err != nil {
		log.Panicln(err)
	}
	if len(os.Getenv(KeyLogly)) > 0 {
		log.Printf("Loading logly token %s \n", os.Getenv(KeyLogly))
		hook := logrusly.NewLogglyHook(os.Getenv(KeyLogly),
			app.Host,
			log.InfoLevel,
			app.Name)
		log.AddHook(hook)
	}

	log.Println("#### LOADED CONFIG #####")
	log.Printf("REDIS_URI: %s \n", rdis.URI)
	log.Printf("NATS_ENDPOINT: %s \n", nats.Endpoint)
}
func main() {
	log := logrus.New()
	hook := logrusly.NewLogglyHook(logglyToken, "https://logs-01.loggly.com/bulk/", logrus.WarnLevel, "go", "logrus")
	log.Hooks.Add(hook)

	log.WithFields(logrus.Fields{
		"name": "Slartibartfast",
		"age":  42,
	}).Error("Hello Dent, Arthur Dent!")

	// Flush is automatic for panic/fatal
	// Just make sure to Flush() before exiting or you may lose up to 5 seconds
	// worth of messages.
	hook.Flush()
}
Example #3
0
File: log.go Project: snikch/api
// InitLoggly will create a loggly hook and register it. It will also register
// a lifecycle shutdown callback to flush any remaining logs, if you're using
// the lifecycle package.
func InitLoggly(key, applicationID string, tags ...string) {
	// No-op if no key is set.
	if key == "" {
		return
	}

	hook := logrusly.NewLogglyHook(
		key,
		applicationID,
		logrus.InfoLevel,
		tags...,
	)
	Logger.Hooks.Add(hook)
	lifecycle.RegisterShutdownCallback("loggly", func() error {
		hook.Flush()
		return nil
	})
}
Example #4
0
// loadConfiguration loads the configuration of application
func loadConfiguration(app *AppConfig, mgo *MgoConfig, etcd *EtcdConfig) {
	err := envconfig.Process("core", app)
	if err != nil {
		log.Panicln(err)
	}
	err = envconfig.Process("mongodb", mgo)
	if err != nil {
		log.Panicln(err)
	}
	err = envconfig.Process("etcd", etcd)
	if err != nil {
		log.Panicln(err)
	}
	if len(os.Getenv(KeyLogly)) > 0 {
		hook := logrusly.NewLogglyHook(os.Getenv(KeyLogly),
			app.Host,
			logrus.InfoLevel,
			app.Name)
		logrus.AddHook(hook)
	}
}
Example #5
0
// loadConfiguration loads the configuration of application
func loadConfiguration(app *AppConfig, mgo *MgoConfig, nats *NatsConfig) {
	err := envconfig.Process(ServiceName, app)
	if err != nil {
		log.Panicln(err)
	}
	err = envconfig.Process("mongodb", mgo)
	if err != nil {
		log.Panicln(err)
	}
	err = envconfig.Process("nats", nats)
	if err != nil {
		log.Panicln(err)
	}
	if len(os.Getenv(KeyLogly)) > 0 {
		log.Println("Loading logly token %s", os.Getenv(KeyLogly))
		hook := logrusly.NewLogglyHook(os.Getenv(KeyLogly),
			app.Host,
			log.InfoLevel,
			app.Name)
		log.AddHook(hook)
	}
}
Example #6
0
// New creates a Logger
// Log levels Warn, Error, and Fatal are always logged.
// If debug, all calls will also log caller informaton.
//
// The default format of logs will be JSON. Also supports 'text' which is
// a easier format for people to understand if you are logging to stdout.
func New(settings Settings) (*Log, error) {
	// Setting up Log.
	log := &Log{}
	tracer = NilTracer{}

	// Let's fire up a new logrus
	text := logrus.New()
	text.Level = logrus.DebugLevel

	// Default is text, color me pretty if possible.
	text.Formatter = &logrus.TextFormatter{ForceColors: true}

	var level logrus.Level
	var err error
	var overrideDefaultLevel bool

	switch v := settings.Output.(type) {
	case LogglySettings:
		// Validate that the bare minimum of what is needed is present.
		if v.Token == "" && v.Domain == "" {
			return &Log{}, ErrLogLogglySetup
		}

		if v.Level != "" {
			level, err = logrus.ParseLevel(v.Level)
			if err != nil {
				return log, ErrLogInvalidLevel
			}
			overrideDefaultLevel = true
		}

		var token, domain string
		// Change the formatter to JSON, required here.
		text.Formatter = &logrus.JSONFormatter{}
		// initialize LogglyHook
		token = v.Token
		domain = v.Domain
		// Create new hook
		hook := logrusly.NewLogglyHook(token, domain, level)
		// Add hook tags
		for _, tag := range v.Tags {
			hook.Tag(tag)
		}
		// Finally, add the hook to the logrus
		text.Hooks.Add(hook)
		// Let's add information to the main log.
		log.hook = hook
		log.isLoggly = true
	case Stderr:
		text.Out = os.Stderr

		if v.Format == "json" {
			text.Formatter = &logrus.JSONFormatter{}
		}

		if v.Level != "" {
			level, err = logrus.ParseLevel(v.Level)
			if err != nil {
				return log, ErrLogInvalidLevel
			}
			overrideDefaultLevel = true
		}
	case Stdout:
		text.Out = os.Stdout

		if settings.Trace {
			tracer = StdOutTracer{}
		}

		if v.Format == "json" {
			text.Formatter = &logrus.JSONFormatter{}
		}

		if v.Level != "" {
			level, err = logrus.ParseLevel(v.Level)
			if err != nil {
				return log, ErrLogInvalidLevel
			}
			overrideDefaultLevel = true
		}
	case Disk:
		if v.Path == "" {
			return log, ErrLogInvalidPath
		}

		f, err := os.OpenFile(v.Path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
		if err != nil {
			return log, ErrLogInvalidPath
		}

		text.Out = f
		text.Formatter = &logrus.JSONFormatter{}

		if v.Level != "" {
			level, err = logrus.ParseLevel(v.Level)
			if err != nil {
				return log, err
			}
			overrideDefaultLevel = true
		}
	case Stdiscard:
		text.Out = ioutil.Discard
	default:
		// We should assume text unless overriden otherwise.
		return log, ErrLogInvalidType
	}

	// All the error checking for level has been handled up above.
	if overrideDefaultLevel {
		text.Level = level
	}

	// Log debug / info evaluation
	if text.Level == logrus.DebugLevel {
		log.debug = true
		log.info = true
	}

	if text.Level == logrus.InfoLevel {
		log.debug = false
		log.info = true
	}

	// Let's attach text to the log.
	log.text = text

	return log, nil
}