Ignore traces

golden/go/analysis/status.go

 package analysis
 
 import (
         "fmt"
 
         "github.com/rcrowley/go-metrics"
         "skia.googlesource.com/buildbot.git/golden/go/types"
 )
 
 const (
@@ skipping 34 matching lines @@
 
         // Number of untriaged digests in HEAD.
         UntriagedCount int `json:"untriagedCount"`
 
         // Number of negative digests in HEAD.
         NegativeCount int `json:"negativeCount"`
 }
 
 // calcStatus determines the status based on the current tile. It breaks
 // down the status by individual corpora.
-func (a *Analyzer) calcStatus(labeledTile *LabeledTile) *GUIStatus {
-        corpStatus := make(map[string]*GUICorpusStatus, len(a.currentIndex.corpora))
+func calcStatus(state *AnalyzeState) *GUIStatus {
+        corpStatus := make(map[string]*GUICorpusStatus, len(state.Index.corpora))
         minCommitId := map[string]int{}
         okByCorpus := map[string]bool{}
 
         // Gathers unique labels by corpus and label.
         byCorpus := map[string]map[types.Label]map[string]bool{}
 
-        for _, corpus := range a.currentIndex.corpora {
-                minCommitId[corpus] = len(labeledTile.Commits)
+        for _, corpus := range state.Index.corpora {
+                minCommitId[corpus] = len(state.Tile.Commits)
                 okByCorpus[corpus] = true
                 byCorpus[corpus] = map[types.Label]map[string]bool{
                         types.POSITIVE:  map[string]bool{},
                         types.NEGATIVE:  map[string]bool{},
                         types.UNTRIAGED: map[string]bool{},
                 }
                 if _, ok := corpusGauges[corpus]; !ok {
                         corpusGauges[corpus] = map[types.Label]metrics.Gauge{
                                 types.UNTRIAGED: metrics.NewRegisteredGauge(fmt.Sprintf(METRIC_CORPUS_TMPL, types.UNTRIAGED, corpus), nil),
                                 types.POSITIVE:  metrics.NewRegisteredGauge(fmt.Sprintf(METRIC_CORPUS_TMPL, types.POSITIVE, corpus), nil),
                                 types.NEGATIVE:  metrics.NewRegisteredGauge(fmt.Sprintf(METRIC_CORPUS_TMPL, types.NEGATIVE, corpus), nil),
                         }
                 }
         }
 
         // Iterate over the current traces
         var idx int
         var corpus string
-        for _, testTraces := range labeledTile.Traces {
+        for _, testTraces := range state.Tile.Traces {
                 for _, trace := range testTraces {
                         corpus = trace.Params[types.CORPUS_FIELD]
                         idx = len(trace.Labels) - 1
 
                         okByCorpus[corpus] = okByCorpus[corpus] && (trace.Labels[idx] == types.POSITIVE)
                         if trace.CommitIds[idx] < minCommitId[corpus] {
                                 minCommitId[corpus] = trace.CommitIds[idx]
                         }
                         byCorpus[corpus][trace.Labels[idx]][trace.Digests[idx]] = true
                 }
         }
 
         overallOk := true
         allUntriagedCount := 0
         allPositiveCount := 0
         allNegativeCount := 0
-        for _, corpus := range a.currentIndex.corpora {
+        for _, corpus := range state.Index.corpora {
                 overallOk = overallOk && okByCorpus[corpus]
                 untriagedCount := len(byCorpus[corpus][types.UNTRIAGED])
                 positiveCount := len(byCorpus[corpus][types.POSITIVE])
                 negativeCount := len(byCorpus[corpus][types.NEGATIVE])
                 corpStatus[corpus] = &GUICorpusStatus{
                         OK:             okByCorpus[corpus],
-                        MinCommitHash:  labeledTile.Commits[minCommitId[corpus]].Hash,
+                        MinCommitHash:  state.Tile.Commits[minCommitId[corpus]].Hash,
                         UntriagedCount: untriagedCount,
                         NegativeCount:  negativeCount,
                 }
                 allUntriagedCount += untriagedCount
                 allNegativeCount += negativeCount
                 allPositiveCount += positiveCount
 
                 corpusGauges[corpus][types.POSITIVE].Update(int64(positiveCount))
                 corpusGauges[corpus][types.NEGATIVE].Update(int64(negativeCount))
                 corpusGauges[corpus][types.UNTRIAGED].Update(int64(untriagedCount))
         }
         allUntriagedGauge.Update(int64(allUntriagedCount))
         allPositiveGauge.Update(int64(allPositiveCount))
         allNegativeGauge.Update(int64(allNegativeCount))
         totalGauge.Update(int64(allUntriagedCount + allPositiveCount + allNegativeCount))
 
         return &GUIStatus{
                 OK:         overallOk,
                 CorpStatus: corpStatus,
         }
 }