perf: moving to tracebd

perf/go/alerting/alerting.go

 package alerting
 
 import (
         "database/sql"
         "encoding/json"
         "fmt"
         "math"
         "time"
 
         metrics "github.com/rcrowley/go-metrics"
         "github.com/skia-dev/glog"
 
         "go.skia.org/infra/go/issues"
         "go.skia.org/infra/go/metadata"
-        "go.skia.org/infra/go/tiling"
+        tracedb "go.skia.org/infra/go/trace/db"
         "go.skia.org/infra/go/util"
         "go.skia.org/infra/perf/go/clustering"
         "go.skia.org/infra/perf/go/config"
         "go.skia.org/infra/perf/go/db"
         "go.skia.org/infra/perf/go/types"
 )
 
 const (
         CLUSTER_SIZE   = 50
         CLUSTER_STDDEV = 0.001
 
         // TRACKED_ITEM_URL_TEMPLATE is used to generate the URL that is
         // embedded in an issue. It is also used to search for issues linked to a
         // specific item (cluster). The format verb is to be replaced with the ID
         // of the tracked item.
         TRACKED_ITEM_URL_TEMPLATE = "https://perf.skia.org/cl/%d"
 )
 
 var (
         // The number of clusters with a status of "New".
         newClustersGauge = metrics.NewRegisteredGauge("alerting.new", metrics.DefaultRegistry)
 
         // The number of times we've successfully done alert clustering.
         runsCounter = metrics.NewRegisteredCounter("alerting.runs", metrics.DefaultRegistry)
 
         // How long it takes to do a clustering run.
         alertingLatency = metrics.NewRegisteredTimer("alerting.latency", metrics.DefaultRegistry)
 
-        // tileStore is the TileStore we are alerting on.
-        tileStore tiling.TileStore
+        // tileBuilder is the tracedb.Builder where we load Tiles from.
+        tileBuilder *tracedb.Builder
 )
 
 // CombineClusters combines freshly found clusters with existing clusters.
 //
 //  Algorithm:
 //    Run clustering and pick out the "Interesting" clusters.
 //    Compare all the Interesting clusters to all the existing relevant clusters,
 //      where "relevant" clusters are ones whose Hash/timestamp of the step
 //      exists in the current tile.
 //    Start with an empty "list".
@@ skipping 209 matching lines @@
         if !util.Int64Equal(bugs, c.Bugs) {
                 c.Bugs = bugs
                 if err := Write(c); err != nil {
                         return fmt.Errorf("Alerting: Failed to write updated cluster with bugs: %s", err)
                 }
         }
         return nil
 }
 
 // singleStep does a single round of alerting.
-func singleStep(tileStore tiling.TileStore, issueTracker issues.IssueTracker) {
+func singleStep(issueTracker issues.IssueTracker) {
         latencyBegin := time.Now()
-        tile, err := tileStore.Get(0, -1)
-        if err != nil {
-                glog.Errorf("Alerting: Failed to get tile: %s", err)
-                return
-        }
-
+        tile := tileBuilder.GetTile()
         summary, err := clustering.CalculateClusterSummaries(tile, CLUSTER_SIZE, CLUSTER_STDDEV, skpOnly)
         if err != nil {
                 glog.Errorf("Alerting: Failed to calculate clusters: %s", err)
                 return
         }
         fresh := []*types.ClusterSummary{}
         for _, c := range summary.Clusters {
                 if math.Abs(c.StepFit.Regression) > clustering.INTERESTING_THRESHHOLD {
                         fresh = append(fresh, c)
                 }
@@ skipping 38 matching lines @@
                 }
         }
         newClustersGauge.Update(int64(count))
         runsCounter.Inc(1)
         alertingLatency.UpdateSince(latencyBegin)
 }
 
 // calcNewClusters counts how many clusters are "New" and updates
 // the newClusterGauge metric accordingly.
 func calcNewClusters() {
-        tile, err := tileStore.Get(0, -1)
-        if err != nil {
-                glog.Errorf("Alerting: Failed to get tile: %s", err)
-                return
-        }
+        tile := tileBuilder.GetTile()
         current, err := ListFrom(tile.Commits[0].CommitTime)
         if err != nil {
                 glog.Errorf("Alerting: Failed to get existing clusters: %s", err)
                 return
         }
         count := 0
         for _, c := range current {
                 if c.Status == "New" {
                         count++
                 }
         }
         glog.Infof("Updated new cluster count: %d", count)
         newClustersGauge.Update(int64(count))
 }
 
 // Start kicks off a go routine the periodically refreshes the current alerting clusters.
-func Start(ts tiling.TileStore, apiKeyFlag string) {
+func Start(tb *tracedb.Builder, apiKeyFlag string) {
+        tileBuilder = tb
         apiKey := apiKeyFromFlag(apiKeyFlag)
         var issueTracker issues.IssueTracker = nil
         if apiKey != "" {
                 issueTracker = issues.NewIssueTracker(apiKey)
         }
 
-        tileStore = ts
         go func() {
                 for _ = range time.Tick(config.RECLUSTER_DURATION) {
-                        singleStep(ts, issueTracker)
+                        singleStep(issueTracker)
                 }
         }()
 }