Make memlock less verbose.

appengine/memlock/memlock.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // Package memlock allows multiple appengine handlers to coordinate best-effort
 // mutual execution via memcache. "best-effort" here means "best-effort"...
 // memcache is not reliable. However, colliding on memcache is a lot cheaper
 // than, for example, colliding with datastore transactions.
 package memlock
 
@@ skipping 53 matching lines @@
 // Note that the lock provided by TryWithLock is a best-effort lock... some
 // other form of locking or synchronization should be used inside of f (such as
 // Datastore transactions) to ensure that f is, in fact, operating exclusively.
 // The purpose of TryWithLock is to have a cheap filter to prevent unnecessary
 // contention on heavier synchronization primitives like transactions.
 func TryWithLock(ctx context.Context, key, clientID string, f func(context.Context) error) error {
         if len(clientID) == 0 {
                 return ErrEmptyClientID
         }
 
-        ctx = logging.SetField(ctx, "key", key)
-        ctx = logging.SetField(ctx, "clientID", clientID)
-        log := logging.Get(ctx)
+        log := logging.Get(
+                logging.SetFields(ctx, logging.Fields{
+                        "key":      key,
+                        "clientID": clientID,
+                }))
         mc := memcache.Get(ctx)
 
         key = memlockKeyPrefix + key
         cid := []byte(clientID)
 
         // checkAnd gets the current value from memcache, and then attempts to do the
         // checkOp (which can either be `refresh` or `release`). These pieces of
         // functionality are necessarially intertwined, because CAS only works with
         // the exact-same *Item which was returned from a Get.
         //
@@ skipping 77 matching lines @@
                 }
 
                 if testStopCB != nil {
                         testStopCB()
                 }
                 checkAnd(release)
         }()
 
         return f(subCtx)
 }