@@ -8,8 +8,10 @@ import (

 	"io/ioutil"

 	"net/http"

 	"os"

+	"time"

 	log "github.com/Sirupsen/logrus"

+	"github.com/Sirupsen/logrus/formatters/logstash"

 	"github.com/docker/distribution/configuration"

 	"github.com/docker/distribution/context"

 	"github.com/docker/distribution/digest"

@@ -19,6 +21,7 @@ import (

 	"github.com/docker/distribution/registry/handlers"

 	_ "github.com/docker/distribution/registry/storage/driver/filesystem"

 	_ "github.com/docker/distribution/registry/storage/driver/s3"

+	"github.com/docker/distribution/uuid"

 	"github.com/docker/distribution/version"

 	gorillahandlers "github.com/gorilla/handlers"

 	"github.com/openshift/origin/pkg/cmd/server/crypto"

@@ -32,15 +35,15 @@ func Execute(configFile io.Reader) {

 		log.Fatalf("Error parsing configuration file: %s", err)

 	}

-	logLevel, err := log.ParseLevel(string(config.Log.Level))

+	ctx := context.Background()

+	ctx, err = configureLogging(ctx, config)

 	if err != nil {

-		log.Errorf("Error parsing log level %q: %s", config.Log.Level, err)

-		logLevel = log.InfoLevel

+		log.Fatalf("error configuring logger: %v", err)

 	}

-	log.SetLevel(logLevel)

-

 	log.Infof("version=%s", version.Version)

-	ctx := context.Background()

+	// inject a logger into the uuid library. warns us if there is a problem

+	// with uuid generation under low entropy.

+	uuid.Loggerf = context.GetLogger(ctx).Warnf

 	app := handlers.NewApp(ctx, config)

@@ -140,6 +143,71 @@ func Execute(configFile io.Reader) {

 	}

 }

+// configureLogging prepares the context with a logger using the

+// configuration.

+func configureLogging(ctx context.Context, config *configuration.Configuration) (context.Context, error) {

+	if config.Log.Level == "" && config.Log.Formatter == "" {

+		// If no config for logging is set, fallback to deprecated "Loglevel".

+		log.SetLevel(logLevel(config.Loglevel))

+		ctx = context.WithLogger(ctx, context.GetLogger(ctx))

+		return ctx, nil

+	}

+

+	log.SetLevel(logLevel(config.Log.Level))

+

+	formatter := config.Log.Formatter

+	if formatter == "" {

+		formatter = "text" // default formatter

+	}

+

+	switch formatter {

+	case "json":

+		log.SetFormatter(&log.JSONFormatter{

+			TimestampFormat: time.RFC3339Nano,

+		})

+	case "text":

+		log.SetFormatter(&log.TextFormatter{

+			TimestampFormat: time.RFC3339Nano,

+		})

+	case "logstash":

+		log.SetFormatter(&logstash.LogstashFormatter{

+			TimestampFormat: time.RFC3339Nano,

+		})

+	default:

+		// just let the library use default on empty string.

+		if config.Log.Formatter != "" {

+			return ctx, fmt.Errorf("unsupported logging formatter: %q", config.Log.Formatter)

+		}

+	}

+

+	if config.Log.Formatter != "" {

+		log.Debugf("using %q logging formatter", config.Log.Formatter)

+	}

+

+	if len(config.Log.Fields) > 0 {

+		// build up the static fields, if present.

+		var fields []interface{}

+		for k := range config.Log.Fields {

+			fields = append(fields, k)

+		}

+

+		ctx = context.WithValues(ctx, config.Log.Fields)

+		ctx = context.WithLogger(ctx, context.GetLogger(ctx, fields...))

+	}

+

+	return ctx, nil

+}

+

+func logLevel(level configuration.Loglevel) log.Level {

+	l, err := log.ParseLevel(string(level))

+	if err != nil {

+		l = log.InfoLevel

+		log.Warnf("error parsing level %q: %v, using %q	", level, err, l)

+	}

+

+	return l

+}

+

 // alive simply wraps the handler with a route that always returns an http 200

 // response when the path is matched. If the path is not matched, the request

 // is passed to the provided handler. There is no guarantee of anything but

@@ -4,8 +4,8 @@ import (

 	"fmt"

 	"net/http"

-	"github.com/Sirupsen/logrus"

 	"github.com/docker/distribution"

+	"github.com/docker/distribution/context"

 	ctxu "github.com/docker/distribution/context"

 	"github.com/docker/distribution/digest"

 	"github.com/docker/distribution/registry/api/errcode"

@@ -163,7 +163,7 @@ func ignoreNotFoundError(ctx *handlers.Context, err error, unknownErrorDetail st

 				return err

 			}

 		}

-		logrus.Infof("%T: ignoring %T error: %v", ctx, err, err)

+		context.GetLogger(ctx).Infof("%T: ignoring %T error: %v", ctx, err, err)

 	}

 	return nil

@@ -112,7 +112,7 @@ func (ac *AccessController) Authorized(ctx context.Context, accessRecords ...reg

 		return nil, ac.wrapErr(err)

 	}

-	bearerToken, err := getToken(req)

+	bearerToken, err := getToken(ctx, req)

 	if err != nil {

 		return nil, ac.wrapErr(err)

 	}

@@ -124,7 +124,7 @@ func (ac *AccessController) Authorized(ctx context.Context, accessRecords ...reg

 	// In case of docker login, hits endpoint /v2

 	if len(accessRecords) == 0 {

-		if err := verifyOpenShiftUser(client); err != nil {

+		if err := verifyOpenShiftUser(ctx, client); err != nil {

 			return nil, ac.wrapErr(err)

 		}

 	}

@@ -134,7 +134,7 @@ func (ac *AccessController) Authorized(ctx context.Context, accessRecords ...reg

 	// Validate all requested accessRecords

 	// Only return failure errors from this loop. Success should continue to validate all records

 	for _, access := range accessRecords {

-		log.Debugf("Origin auth: checking for access to %s:%s:%s", access.Resource.Type, access.Resource.Name, access.Action)

+		context.GetLogger(ctx).Debugf("Origin auth: checking for access to %s:%s:%s", access.Resource.Type, access.Resource.Name, access.Action)

 		switch access.Resource.Type {

 		case "repository":

@@ -160,12 +160,12 @@ func (ac *AccessController) Authorized(ctx context.Context, accessRecords ...reg

 				if verifiedPrune {

 					continue

 				}

-				if err := verifyPruneAccess(client); err != nil {

+				if err := verifyPruneAccess(ctx, client); err != nil {

 					return nil, ac.wrapErr(err)

 				}

 				verifiedPrune = true

 			default:

-				if err := verifyImageStreamAccess(imageStreamNS, imageStreamName, verb, client); err != nil {

+				if err := verifyImageStreamAccess(ctx, imageStreamNS, imageStreamName, verb, client); err != nil {

 					return nil, ac.wrapErr(err)

 				}

 			}

@@ -176,7 +176,7 @@ func (ac *AccessController) Authorized(ctx context.Context, accessRecords ...reg

 				if verifiedPrune {

 					continue

 				}

-				if err := verifyPruneAccess(client); err != nil {

+				if err := verifyPruneAccess(ctx, client); err != nil {

 					return nil, ac.wrapErr(err)

 				}

 				verifiedPrune = true

@@ -207,7 +207,7 @@ func getNamespaceName(resourceName string) (string, string, error) {

 	return ns, name, nil

 }

-func getToken(req *http.Request) (string, error) {

+func getToken(ctx context.Context, req *http.Request) (string, error) {

 	authParts := strings.SplitN(req.Header.Get("Authorization"), " ", 2)

 	if len(authParts) != 2 || strings.ToLower(authParts[0]) != "basic" {

 		return "", ErrTokenRequired

@@ -216,7 +216,7 @@ func getToken(req *http.Request) (string, error) {

 	payload, err := base64.StdEncoding.DecodeString(basicToken)

 	if err != nil {

-		log.Errorf("Basic token decode failed: %s", err)

+		context.GetLogger(ctx).Errorf("Basic token decode failed: %s", err)

 		return "", ErrTokenInvalid

 	}

@@ -229,9 +229,9 @@ func getToken(req *http.Request) (string, error) {

 	return bearerToken, nil

 }

-func verifyOpenShiftUser(client *client.Client) error {

+func verifyOpenShiftUser(ctx context.Context, client *client.Client) error {

 	if _, err := client.Users().Get("~"); err != nil {

-		log.Errorf("Get user failed with error: %s", err)

+		context.GetLogger(ctx).Errorf("Get user failed with error: %s", err)

 		if kerrors.IsUnauthorized(err) || kerrors.IsForbidden(err) {

 			return ErrOpenShiftAccessDenied

 		}

@@ -241,7 +241,7 @@ func verifyOpenShiftUser(client *client.Client) error {

 	return nil

 }

-func verifyImageStreamAccess(namespace, imageRepo, verb string, client *client.Client) error {

+func verifyImageStreamAccess(ctx context.Context, namespace, imageRepo, verb string, client *client.Client) error {

 	sar := authorizationapi.LocalSubjectAccessReview{

 		Action: authorizationapi.AuthorizationAttributes{

 			Verb:         verb,

@@ -252,7 +252,7 @@ func verifyImageStreamAccess(namespace, imageRepo, verb string, client *client.C

 	response, err := client.LocalSubjectAccessReviews(namespace).Create(&sar)

 	if err != nil {

-		log.Errorf("OpenShift client error: %s", err)

+		context.GetLogger(ctx).Errorf("OpenShift client error: %s", err)

 		if kerrors.IsUnauthorized(err) || kerrors.IsForbidden(err) {

 			return ErrOpenShiftAccessDenied

 		}

@@ -260,14 +260,14 @@ func verifyImageStreamAccess(namespace, imageRepo, verb string, client *client.C

 	}

 	if !response.Allowed {

-		log.Errorf("OpenShift access denied: %s", response.Reason)

+		context.GetLogger(ctx).Errorf("OpenShift access denied: %s", response.Reason)

 		return ErrOpenShiftAccessDenied

 	}

 	return nil

 }

-func verifyPruneAccess(client *client.Client) error {

+func verifyPruneAccess(ctx context.Context, client *client.Client) error {

 	sar := authorizationapi.SubjectAccessReview{

 		Action: authorizationapi.AuthorizationAttributes{

 			Verb:     "delete",

@@ -276,14 +276,14 @@ func verifyPruneAccess(client *client.Client) error {

 	}

 	response, err := client.SubjectAccessReviews().Create(&sar)

 	if err != nil {

-		log.Errorf("OpenShift client error: %s", err)

+		context.GetLogger(ctx).Errorf("OpenShift client error: %s", err)

 		if kerrors.IsUnauthorized(err) || kerrors.IsForbidden(err) {

 			return ErrOpenShiftAccessDenied

 		}

 		return err

 	}

 	if !response.Allowed {

-		log.Errorf("OpenShift access denied: %s", response.Reason)

+		context.GetLogger(ctx).Errorf("OpenShift access denied: %s", response.Reason)

 		return ErrOpenShiftAccessDenied

 	}

 	return nil

@@ -10,11 +10,11 @@ import (

 	"testing"

 	"github.com/docker/distribution/registry/auth"

-	"golang.org/x/net/context"

 	kapi "k8s.io/kubernetes/pkg/api"

 	"k8s.io/kubernetes/pkg/runtime"

+	"github.com/docker/distribution/context"

 	"github.com/openshift/origin/pkg/api/latest"

 	"github.com/openshift/origin/pkg/authorization/api"

 	userapi "github.com/openshift/origin/pkg/user/api"

@@ -58,12 +58,13 @@ func TestVerifyImageStreamAccess(t *testing.T) {

 		},

 	}

 	for _, test := range tests {

+		ctx := context.Background()

 		server, _ := simulateOpenShiftMaster([]response{test.openshiftResponse})

 		client, err := NewUserOpenShiftClient("magic bearer token")

 		if err != nil {

 			t.Fatal(err)

 		}

-		err = verifyImageStreamAccess("foo", "bar", "create", client)

+		err = verifyImageStreamAccess(ctx, "foo", "bar", "create", client)

 		if err == nil || test.expectedError == nil {

 			if err != test.expectedError {

 				t.Fatalf("verifyImageStreamAccess did not get expected error - got %s - expected %s", err, test.expectedError)

@@ -271,7 +272,7 @@ func TestAccessController(t *testing.T) {

 		if len(test.basicToken) > 0 {

 			req.Header.Set("Authorization", fmt.Sprintf("Basic %s", test.basicToken))

 		}

-		ctx := context.WithValue(nil, "http.request", req)

+		ctx := context.WithValue(context.Background(), "http.request", req)

 		server, actions := simulateOpenShiftMaster(test.openshiftResponses)

 		authCtx, err := accessController.Authorized(ctx, test.access...)

@@ -8,7 +8,6 @@ import (

 	"os"

 	"strings"

-	log "github.com/Sirupsen/logrus"

 	"github.com/docker/distribution"

 	"github.com/docker/distribution/context"

 	"github.com/docker/distribution/digest"

@@ -112,13 +111,13 @@ func (r *repository) ExistsByTag(tag string) (bool, error) {

 // Get retrieves the manifest with digest `dgst`.

 func (r *repository) Get(dgst digest.Digest) (*schema1.SignedManifest, error) {

 	if _, err := r.getImageStreamImage(dgst); err != nil {

-		log.Errorf("Error retrieving ImageStreamImage %s/%s@%s: %v", r.namespace, r.name, dgst.String(), err)

+		context.GetLogger(r.ctx).Errorf("Error retrieving ImageStreamImage %s/%s@%s: %v", r.namespace, r.name, dgst.String(), err)

 		return nil, err

 	}

 	image, err := r.getImage(dgst)

 	if err != nil {

-		log.Errorf("Error retrieving image %s: %v", dgst.String(), err)

+		context.GetLogger(r.ctx).Errorf("Error retrieving image %s: %v", dgst.String(), err)

 		return nil, err

 	}

@@ -139,20 +138,20 @@ func (r *repository) GetByTag(tag string, options ...distribution.ManifestServic

 	}

 	imageStreamTag, err := r.getImageStreamTag(tag)

 	if err != nil {

-		log.Errorf("Error getting ImageStreamTag %q: %v", tag, err)

+		context.GetLogger(r.ctx).Errorf("Error getting ImageStreamTag %q: %v", tag, err)

 		return nil, err

 	}

 	image := &imageStreamTag.Image

 	dgst, err := digest.ParseDigest(imageStreamTag.Image.Name)

 	if err != nil {

-		log.Errorf("Error parsing digest %q: %v", imageStreamTag.Image.Name, err)

+		context.GetLogger(r.ctx).Errorf("Error parsing digest %q: %v", imageStreamTag.Image.Name, err)

 		return nil, err

 	}

 	image, err = r.getImage(dgst)

 	if err != nil {

-		log.Errorf("Error getting image %q: %v", dgst.String(), err)

+		context.GetLogger(r.ctx).Errorf("Error getting image %q: %v", dgst.String(), err)

 		return nil, err

 	}

@@ -196,13 +195,13 @@ func (r *repository) Put(manifest *schema1.SignedManifest) error {

 		// if the error was that the image stream wasn't found, try to auto provision it

 		statusErr, ok := err.(*kerrors.StatusError)

 		if !ok {

-			log.Errorf("Error creating ImageStreamMapping: %s", err)

+			context.GetLogger(r.ctx).Errorf("Error creating ImageStreamMapping: %s", err)

 			return err

 		}

 		status := statusErr.ErrStatus

 		if status.Code != http.StatusNotFound || status.Details.Kind != "imageStream" || status.Details.Name != r.name {

-			log.Errorf("Error creating ImageStreamMapping: %s", err)

+			context.GetLogger(r.ctx).Errorf("Error creating ImageStreamMapping: %s", err)

 			return err

 		}

@@ -214,18 +213,18 @@ func (r *repository) Put(manifest *schema1.SignedManifest) error {

 		client, ok := UserClientFrom(r.ctx)

 		if !ok {

-			log.Errorf("Error creating user client to auto provision image stream: Origin user client unavailable")

+			context.GetLogger(r.ctx).Errorf("Error creating user client to auto provision image stream: Origin user client unavailable")

 			return statusErr

 		}

 		if _, err := client.ImageStreams(r.namespace).Create(&stream); err != nil {

-			log.Errorf("Error auto provisioning image stream: %s", err)

+			context.GetLogger(r.ctx).Errorf("Error auto provisioning image stream: %s", err)

 			return statusErr

 		}

 		// try to create the ISM again

 		if err := r.registryClient.ImageStreamMappings(r.namespace).Create(&ism); err != nil {

-			log.Errorf("Error creating image stream mapping: %s", err)

+			context.GetLogger(r.ctx).Errorf("Error creating image stream mapping: %s", err)

 			return err

 		}

 	}

@@ -238,7 +237,7 @@ func (r *repository) Put(manifest *schema1.SignedManifest) error {

 	for _, signature := range signatures {

 		if err := r.Signatures().Put(dgst, signature); err != nil {

-			log.Errorf("Error storing signature: %s", err)

+			context.GetLogger(r.ctx).Errorf("Error storing signature: %s", err)

 			return err

 		}

 	}