perf: moving to tracebd

go/trace/db/db.go

 // Package tracedb provides a datastore for efficiently storing and retrieving traces.
 package db
 
 import (
         "fmt"
         "sync"
         "time"
 
         "github.com/golang/groupcache/lru"
         "github.com/skia-dev/glog"
@@ skipping 110 matching lines @@
         return ret, nil
 }
 
 func (ts *TsDB) ping() error {
         _, err := ts.traceService.Ping(ts.ctx, &traceservice.Empty{})
         return err
 }
 
 // addChunk adds a set of entries to the datastore at the given CommitID.
 func (ts *TsDB) addChunk(ctx context.Context, cid *traceservice.CommitID, chunk map[string]*Entry) error {
+        if len(chunk) == 0 {
+                return nil
+        }
         addReq := &traceservice.AddRequest{
                 Commitid: cid,
                 Values:   []*traceservice.ValuePair{},
         }
         addParamsRequest := &traceservice.AddParamsRequest{
                 Params: []*traceservice.ParamsPair{},
         }
         for traceid, entry := range chunk {
                 // Check that all the traceids have their Params.
                 if _, ok := ts.cache.Get(traceid); !ok {
                         addParamsRequest.Params = append(addParamsRequest.Params, &traceservice.ParamsPair{
                                 Key:    traceid,
                                 Params: entry.Params,
                         })
                         ts.cache.Add(traceid, true)
                 }
                 addReq.Values = append(addReq.Values, &traceservice.ValuePair{
                         Key:   traceid,
                         Value: entry.Value,
                 })
         }
         if len(addParamsRequest.Params) > 0 {
-                _, err := ts.traceService.AddParams(ctx, addParamsRequest)
-                if err != nil {
+                if _, err := ts.traceService.AddParams(ctx, addParamsRequest); err != nil {
                         return fmt.Errorf("Failed to add params: %s", err)
                 }
         }
         if _, err := ts.traceService.Add(ctx, addReq); err != nil {
                 return fmt.Errorf("Failed to add values: %s", err)
         }
         return nil
 }
 
 // tsCommitID converts a db.CommitID to traceservice.CommitID.
@@ skipping 103 matching lines @@
                         // Load the values for the commit.
                         getValuesRequest := &traceservice.GetValuesRequest{
                                 Commitid: tsCommitID(cid),
                         }
                         getValuesResponse, err := ts.traceService.GetValues(ctx, getValuesRequest)
                         if err != nil {
                                 errCh <- fmt.Errorf("Failed to get values for %d %#v: %s", i, *cid, err)
                                 return
                         }
                         for _, pair := range getValuesResponse.Values {
+                                if pair == nil {
+                                        glog.Errorf("Got a nil ValuePair in response: %s", err)
+                                        continue
+                                }
                                 tr, ok := tile.Traces[pair.Key]
                                 if !ok {
                                         tileMutex.Lock()
                                         tile.Traces[pair.Key] = ts.traceBuilder(n)
                                         tileMutex.Unlock()
                                         tr = tile.Traces[pair.Key]
                                 }
                                 if err := tr.SetAt(i, pair.Value); err != nil {
                                         errCh <- fmt.Errorf("Unable to convert trace value %d %#v: %s", i, *cid, err)
                                         return
@@ skipping 82 matching lines @@
                 return nil, fmt.Errorf("Did not get address for trace services.")
         }
 
         conn, err := grpc.Dial(traceServiceAddr, grpc.WithInsecure())
         if err != nil {
                 return nil, fmt.Errorf("Unable to connnect to trace service at %s. Got error: %s", traceServiceAddr, err)
         }
 
         return NewTraceServiceDB(conn, traceBuilder)
 }