dscache: Reduce log level of memcache failures.

filter/dscache/ds.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package dscache
 
 import (
         "time"
 
         ds "github.com/luci/gae/service/datastore"
@@ skipping 28 matching lines @@
         if len(lockItems) == 0 {
                 return d.RawInterface.GetMulti(keys, metas, cb)
         }
 
         if err := d.mc.AddMulti(lockItems); err != nil {
                 // Ignore this error. Either we couldn't add them because they exist
                 // (so, not an issue), or because memcache is having sad times (in which
                 // case we'll see so in the GetMulti which immediately follows this).
         }
         if err := errors.Filter(d.mc.GetMulti(lockItems), memcache.ErrCacheMiss); err != nil {
-                (log.Fields{log.ErrorKey: err}).Warningf(
+                (log.Fields{log.ErrorKey: err}).Debugf(
                         d.c, "dscache: GetMulti: memcache.GetMulti")
         }
 
         p := makeFetchPlan(d.c, d.aid, d.ns, &facts{keys, metas, lockItems, nonce})
 
         if !p.empty() {
                 // looks like we have something to pull from datastore, and maybe some work
                 // to save stuff back to memcache.
 
                 toCas := []memcache.Item{}
@@ skipping 43 matching lines @@
                                 toCas = append(toCas, toSave)
                         }
                         return nil
                 })
                 if err != nil {
                         return err
                 }
                 if len(toCas) > 0 {
                         // we have entries to save back to memcache.
                         if err := d.mc.CompareAndSwapMulti(toCas); err != nil {
-                                (log.Fields{log.ErrorKey: err}).Warningf(
+                                (log.Fields{log.ErrorKey: err}).Debugf(
                                         d.c, "dscache: GetMulti: memcache.CompareAndSwapMulti")
                         }
                 }
         }
 
         // finally, run the callback for all of the decoded items and the errors,
         // if any.
         for i, dec := range p.decoded {
                 if err := cb(dec, p.lme.GetOne(i)); err != nil {
                         return err
@@ skipping 11 matching lines @@
                 if err == nil {
                         err = txnState.apply(d.supportContext)
                 }
                 return err
         }, opts)
         if err == nil {
                 txnState.release(d.supportContext)
         }
         return err
 }