func newInstanceCleaner( cs *compute.Service, log *logrus.Logger, rateLimiter ratelimit.RateLimiter, rateLimitMaxCalls uint64, rateLimitDuration time.Duration, cutoffTime time.Time, projectID string, filters []string, noop bool, ) *instanceCleaner { return &instanceCleaner{ cs: cs, log: log.WithField("component", "instance_cleaner"), projectID: projectID, filters: filters, noop: noop, CutoffTime: cutoffTime, rateLimiter: rateLimiter, rateLimitMaxCalls: rateLimitMaxCalls, rateLimitDuration: rateLimitDuration, } }
func newImageCleaner( cs *compute.Service, log *logrus.Logger, rateLimiter ratelimit.RateLimiter, rateLimitMaxCalls uint64, rateLimitDuration time.Duration, projectID, jobBoardURL string, filters []string, noop bool, ) *imageCleaner { return &imageCleaner{ cs: cs, log: log.WithField("component", "image_cleaner"), projectID: projectID, jobBoardURL: jobBoardURL, filters: filters, noop: noop, rateLimiter: rateLimiter, rateLimitMaxCalls: rateLimitMaxCalls, rateLimitDuration: rateLimitDuration, } }
//Logging logs http requests func Logging(next http.Handler, log *logrus.Logger) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { srw := StatusResponseWriter{w, 0, 0} start := time.Now() next.ServeHTTP(&srw, r) end := time.Now() latency := end.Sub(start) log.WithField("client", r.RemoteAddr).WithField("latency", latency).WithField("length", srw.Length()).WithField("code", srw.Status()).Printf("%s %s %s", r.Method, r.URL, r.Proto) }) }
// Build an adequate instance of the structured logger for this // application instance. The journal builder may draw data from the // app instance to configure the journal correctly. This method only // instantiates a very basic journal; anything more complicated than // that should be implementing using a boot.Provider to do it. func (app *App) makeJournal(level logrus.Level) *logrus.Logger { const m = "begin writing application journal" var journal *logrus.Logger = &logrus.Logger{} formatter := new(logrus.TextFormatter) // std journal.Level = level // use requested level journal.Out = os.Stdout // all goes to stdout journal.Hooks = make(logrus.LevelHooks) // empty journal.Formatter = formatter // set formatter formatter.ForceColors = false // act smart formatter.DisableColors = false // make pretty formatter.DisableTimestamp = false // is useful formatter.FullTimestamp = false // numbers formatter.TimestampFormat = time.StampMilli formatter.DisableSorting = false // order! moment := time.Now().Format(app.TimeLayout) journal.WithField("time", moment).Info(m) return journal // is ready to use }
// NewS3Store initializes an *S3Store. Wow! func NewS3Store(key, secret, bucket, regionName string, log *logrus.Logger, md metadata.LookupSaver) (*S3Store, error) { log.Debug("getting aws auth") auth, err := aws.GetAuth(key, secret) if err != nil { log.WithField("err", err).Error("failed to get auth") return nil, err } region, ok := aws.Regions[regionName] if !ok { log.WithFields(logrus.Fields{ "region": regionName, }).Warn(fmt.Sprintf("nonexistent region, falling back to %s", aws.USEast.Name)) region = aws.USEast } log.Debug("getting new s3 connection") s3Conn := s3.New(auth, region) b := s3Conn.Bucket(bucket) if b == nil || b.Name == "" { return nil, errNoBucket } log.WithFields(logrus.Fields{ "bucket": b.Name, }).Debug("got back this bucket") return &S3Store{ key: key, secret: secret, bucket: bucket, log: log, md: md, b: b, }, nil }
// LogCallback returns a callback that logs an error to logger with msg at Warn func LogCallback(msg string, l *log.Logger) ErrCallback { return func(err error) { l.WithField("err", err.Error()).Warn(msg) } }