Metrics2: Store a registry of Counters

fuzzer/go/aggregator/aggregator.go

 package aggregator
 
 import (
         "bytes"
         "crypto/sha1"
         "fmt"
         "io"
         "io/ioutil"
         "os"
         "path/filepath"
@@ skipping 343 matching lines @@
         }
         return badFuzzPaths, nil
 }
 
 // waitForAnalysis waits for files that need to be analyzed (from forAnalysis) and makes a copy of
 // them in agg.fuzzPath with their hash as a file name. It then analyzes it using the supplied
 // AnalysisPackage and then signals the results should be uploaded. If any unrecoverable errors
 // happen, this method terminates.
 func (agg *Aggregator) waitForAnalysis(identifier int) {
         defer agg.aggregationWaitGroup.Done()
-        defer metrics2.NewCounter("analysis-process-count", nil).Dec(int64(1))
+        defer metrics2.GetCounter("analysis-process-count", nil).Dec(int64(1))
         glog.Infof("Spawning analyzer %d", identifier)
 
         // our own unique working folder
         executableDir := filepath.Join(config.Aggregator.ExecutablePath, fmt.Sprintf("analyzer%d", identifier))
         if err := setupAnalysis(executableDir); err != nil {
                 glog.Errorf("Analyzer %d terminated due to error: %s", identifier, err)
                 return
         }
         for {
                 select {
@@ skipping 157 matching lines @@
 // Append adds all of the strings to the underlying slice and sorts it
 func (s *SortedStringSlice) Append(strs []string) {
         s.strings = append(s.strings, strs...)
         s.strings.Sort()
 }
 
 // waitForUploads waits for uploadPackages to be sent through the forUpload channel and then uploads
 // them.  If any unrecoverable errors happen, this method terminates.
 func (agg *Aggregator) waitForUploads(identifier int) {
         defer agg.aggregationWaitGroup.Done()
-        defer metrics2.NewCounter("upload-process-count", nil).Dec(int64(1))
+        defer metrics2.GetCounter("upload-process-count", nil).Dec(int64(1))
         glog.Infof("Spawning uploader %d", identifier)
         for {
                 select {
                 case p := <-agg.forUpload:
                         atomic.AddInt64(&agg.uploadCount, int64(1))
                         if !agg.UploadGreyFuzzes && p.FuzzType == GREY_FUZZ {
                                 glog.Infof("Skipping upload of grey fuzz %s", p.Data.Name)
                                 // We are skipping the bugReport, so increment the counts.
                                 atomic.AddInt64(&agg.bugReportCount, int64(1))
                                 continue
@@ skipping 118 matching lines @@
         if agg.MakeBugOnBadFuzz && p.IsBadFuzz {
                 glog.Warningf("Should create bug for %s", p.FuzzName)
         }
         return nil
 }
 
 // monitorStatus sets up the monitoring routine, which reports how big the work queues are and how
 // many processes are up.
 func (agg *Aggregator) monitorStatus(numAnalysisProcesses, numUploadProcesses int) {
         defer agg.monitoringWaitGroup.Done()
-        analysisProcessCount := metrics2.NewCounter("analysis-process-count", nil)
+        analysisProcessCount := metrics2.GetCounter("analysis-process-count", nil)
         analysisProcessCount.Reset()
         analysisProcessCount.Inc(int64(numAnalysisProcesses))
-        uploadProcessCount := metrics2.NewCounter("upload-process-count", nil)
+        uploadProcessCount := metrics2.GetCounter("upload-process-count", nil)
         uploadProcessCount.Reset()
         uploadProcessCount.Inc(int64(numUploadProcesses))
 
         t := time.Tick(config.Aggregator.StatusPeriod)
         for {
                 select {
                 case <-agg.monitoringShutdown:
                         glog.Info("aggregator monitor got signal to shut down")
                         return
                 case <-t:
@@ skipping 85 matching lines @@
 }
 
 func (agg *Aggregator) ClearUploadedFuzzNames() {
         agg.greyNames = []string{}
         agg.badNames = []string{}
 }
 
 func (agg *Aggregator) UploadedFuzzNames() (bad, grey []string) {
         return agg.badNames, agg.greyNames
 }