Remove log filtering and add stringsetflag.

common/meter/meter.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 meter
 
 import (
         "errors"
 
         "github.com/luci/luci-go/common/clock"
@@ skipping 102 matching lines @@
         default:
                 break
         }
 }
 
 // Main buffering function, which runs in a goroutine.
 func (m *meter) consumeWork() {
         // Acknowledge when this goroutine finishes.
         defer close(m.closeAckC)
 
-        ctx := log.SetFilter(m.ctx, "meter")
-
         timerRunning := false
-        flushTimer := clock.NewTimer(ctx)
+        flushTimer := clock.NewTimer(m.ctx)
         defer func() {
                 flushTimer.Stop()
         }()
 
         flushCount := m.Count
         flushTime := m.Delay
 
         // Build our work buffer.
         workBufferSize := initialWorkBufferSize
         if flushCount > 0 {
                 // Will never buffer more than this much Work.
                 workBufferSize = flushCount
         }
         bufferedWork := make([]interface{}, 0, workBufferSize)
 
-        log.Debugf(ctx, "Starting work loop.")
+        log.Debugf(m.ctx, "Starting work loop.")
         active := true
         for active {
                 flushRound := false
 
                 select {
                 case work, ok := <-m.workC:
                         if !ok {
-                                log.Debugf(ctx, "Received instance close signal; terminating.")
+                                log.Debugf(m.ctx, "Received instance close signal; terminating.")
 
                                 // Don't immediately exit the loop, since there may still be buffered
                                 // Work to flush.
                                 active = false
                                 flushRound = true
                                 break
                         }
 
                         // Count the work in this group. If we're not using a given metric, try
                         // and avoid wasting time collecting it.
                         bufferedWork = append(bufferedWork, work)
 
                         // Handle work count threshold. We do this first, since it's trivial to
                         // setup/compute.
                         if flushCount > 0 && len(bufferedWork) >= flushCount {
                                 flushRound = true
                         }
                         // Start our flush timer, if it's not already ticking. Only waste time
                         // doing this if we're not already flushing, since flushing will clear the
                         // timer.
                         if !flushRound && flushTime > 0 && !timerRunning {
-                                log.Infof(log.SetFields(ctx, log.Fields{
+                                log.Infof(log.SetFields(m.ctx, log.Fields{
                                         "flushInterval": flushTime,
                                 }), "Starting flush timer.")
                                 flushTimer.Reset(flushTime)
                                 timerRunning = true
                         }
 
                         // Invoke work callback, if one is set.
                         if m.IngestCallback != nil {
                                 flushRound = m.IngestCallback(work) || flushRound
                         }
 
                 case <-m.flushNowC:
                         flushRound = true
 
                 case <-flushTimer.GetC():
-                        log.Infof(ctx, "Flush timer has triggered.")
+                        log.Infof(m.ctx, "Flush timer has triggered.")
                         timerRunning = false
                         flushRound = true
                 }
 
                 // Should we flush?
                 if flushRound {
                         flushTimer.Stop()
                         timerRunning = false
 
                         if len(bufferedWork) > 0 {
                                 // Clone bufferedWork, since we re-use it.
                                 workToSend := make([]interface{}, len(bufferedWork))
                                 copy(workToSend, bufferedWork)
 
                                 // Clear our Work slice for re-use. This does not resize the underlying
                                 // array, since it's likely to fill again.
                                 for idx := range bufferedWork {
                                         bufferedWork[idx] = nil
                                 }
                                 bufferedWork = bufferedWork[:0]
 
                                 // Callback with this work.
                                 m.Callback(workToSend)
                         }
                 }
         }
 }