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)
}
}